Upload 41 files

app.py

@@ -0,0 +1,64 @@
+import streamlit as st
+from utils import *
+
+st.set_page_config(
+    page_title="Number to Video",
+    page_icon="🎥",
+    initial_sidebar_state="auto",
+)
+
+# Input number
+number = st.text_input("Enter a number between 1 and 9999999", "24")
+number = int(number)
+
+if number:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        with st.container(border=True):
+            st.subheader("Settings")
+            st.divider()
+
+            # Generate clip sequence based on the number
+            clips = generate_clip_sequence(number)
+            if clips:
+                st.write("Generated Clips Sequence:")
+                for i, clip in enumerate(clips):
+                    st.write(f"Clip {i + 1}: {clip}")
+                submit = st.button("Create Video", use_container_width=True)
+
+    if clips:
+        with st.sidebar:
+            st.title("Advanced Settings")
+            trim_settings = []
+            for i, clip in enumerate(clips):
+                with st.container(border=True):
+                    st.write(f"Adjust settings for {clip}:")
+                    length = get_clip_duration(clip)
+                    default_trim_start = 0.10
+                    default_trim_end = length - 0.10
+                    # trim_bounds = st.slider(
+                    #     f"Trim bounds for {clip}", 
+                    #     0.0, length, 
+                    #     (default_trim_start, default_trim_end), 
+                    #     0.001,
+                    #     key=f"bounds_{i}"
+                    # )
+                    # trim_bounds = tuple([round(b, 2) for b in trim_bounds])
+                    # print(trim_bounds)
+                    # trim_settings.append(trim_bounds)
+
+                    trim_start = st.slider(f"Trim start for {clip}", 0.0, length, 0.10, 0.01, key=f"start_{i}")
+                    trim_end = st.slider(f"Trim end for {clip}", 0.0, length, 0.10, 0.01, key=f"end_{i}")
+                    trim_settings.append((trim_start, trim_end))
+            print(trim_settings)
+
+    with col2:
+        with st.container(border=True):
+            st.subheader("Output")
+            output_file = "output.mp4"
+            if submit:
+                pass
+                # Create the video with individual clip settings
+                create_advanced_video(number, trim_settings, output_file)
+                st.video(output_file, autoplay=True)

app_basic.py

@@ -0,0 +1,29 @@
+import streamlit as st
+from utils import *
+
+st.set_page_config(
+    page_title="Number to Video - Advanced Settings",
+    page_icon="🎥",
+    initial_sidebar_state="collapsed",
+)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    with st.container(border=True):
+        st.subheader("Settings")
+        st.divider()
+        trim_start = st.slider("Trim start", 0.0, 1.0, 0.10, 0.01)
+        trim_end = st.slider("Trim end", 0.0, 1.0, 0.10, 0.01)
+        number = st.text_input("Enter a number between 1 and 9999999", "123")
+        number = int(number)
+        clips = generate_clip_sequence(number)
+        submit = st.button("Create Video", use_container_width=True)
+
+
+with col2:
+    with st.container(border=True):
+        output_file = "output.mp4"
+        if submit:
+            create_video(number, trim_start, trim_end, output_file)
+            st.video(output_file, autoplay=True)

dev.ipynb

@@ -0,0 +1,231 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Clips: ['1.mp4', '1.mp4']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "['1.mp4', '1.mp4']"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "files = {\n",
+    "    1: \"1.mp4\", 2: \"2.mp4\", 3: \"3.mp4\", 4: \"4.mp4\", 5: \"5.mp4\",\n",
+    "    6: \"6.mp4\", 7: \"7.mp4\", 8: \"8.mp4\", 9: \"9.mp4\",\n",
+    "    10: \"10.mp4\", 11: \"11.mp4\", 12: \"12.mp4\", 13: \"13.mp4\", 14: \"14.mp4\",\n",
+    "    15: \"15.mp4\", 16: \"16.mp4\", 17: \"17.mp4\", 18: \"18.mp4\", 19: \"19.mp4\",\n",
+    "    20: \"20.mp4\", 30: \"30.mp4\", 40: \"40.mp4\", 50: \"50.mp4\", \n",
+    "    60: \"60.mp4\", 70: \"70.mp4\", 80: \"80.mp4\", 90: \"90.mp4\",\n",
+    "    100: \"100.mp4\", 1000: \"1000.mp4\",\n",
+    "    100000: \"100000.mp4\"\n",
+    "}\n",
+    "\n",
+    "def get_clips(number):\n",
+    "    num_digits = len(str(number))\n",
+    "    place_values = []\n",
+    "    place = 1\n",
+    "\n",
+    "    # Split number into place values\n",
+    "    while number > 0:\n",
+    "        digit = number % 10\n",
+    "        if digit > 0:\n",
+    "            place_values.append((digit, place))\n",
+    "        number //= 10\n",
+    "        place *= 10\n",
+    "    \n",
+    "    place_values.reverse()  # To process from the highest place value\n",
+    "    clips = []\n",
+    "    i = 0\n",
+    "\n",
+    "    while i < len(place_values):\n",
+    "        digit, place = place_values[i]\n",
+    "\n",
+    "        # Handle cases for 1-20 at specific positions\n",
+    "        if place == 1 and i > 0 and place_values[i - 1][1] == 10:  # Check for numbers ending in 1-20\n",
+    "            combined = place_values[i - 1][0] * 10 + digit\n",
+    "            if 1 <= combined <= 20:\n",
+    "                clips.pop()  # Remove the previous 10's place clip\n",
+    "                clips.append(files[combined])\n",
+    "                i += 1\n",
+    "                continue\n",
+    "        \n",
+    "        if place == 10 and digit * 10 <= 20:  # Numbers between 1-20 at higher positions\n",
+    "            if i + 1 < len(place_values) and place_values[i + 1][1] == 1:\n",
+    "                combined = digit * 10 + place_values[i + 1][0]\n",
+    "                if 1 <= combined <= 20:\n",
+    "                    clips.append(files[combined])\n",
+    "                    i += 2\n",
+    "                    continue\n",
+    "\n",
+    "        # Add individual clips\n",
+    "        if digit in files:\n",
+    "            clips.append(files[digit])\n",
+    "        if digit * place in files:\n",
+    "            clips.append(files[digit * place])\n",
+    "\n",
+    "        i += 1\n",
+    "\n",
+    "    # Handle 10,000 and 10,00,000 special cases\n",
+    "    if len(place_values) % 2 == 1 and place_values[0][1] in [10000, 100000]:\n",
+    "        first_digit = place_values[0][0]\n",
+    "        if 1 <= first_digit <= 20:\n",
+    "            clips.insert(0, files[first_digit])\n",
+    "        elif first_digit * 10 in files:\n",
+    "            clips.insert(0, files[first_digit * 10])\n",
+    "        place_values = place_values[1:]\n",
+    "\n",
+    "    print(\"Clips:\", clips)\n",
+    "    return clips\n",
+    "\n",
+    "# Example usage\n",
+    "number = int(input(\"Enter a number: \"))\n",
+    "get_clips(number)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "99: ['90.mp4', '9.mp4']\n",
+      "111: ['1.mp4', '100.mp4', '11.mp4']\n",
+      "256: ['2.mp4', '100.mp4', '50.mp4', '6.mp4']\n",
+      "1000: ['1.mp4', '1000.mp4']\n",
+      "1011: ['1.mp4', '1000.mp4', '11.mp4']\n",
+      "9999: ['9.mp4', '1000.mp4', '9.mp4', '100.mp4', '90.mp4', '9.mp4']\n",
+      "10000: ['10.mp4', '1000.mp4']\n",
+      "24256: ['20.mp4', '4.mp4', '1000.mp4', '2.mp4', '100.mp4', '50.mp4', '6.mp4']\n",
+      "22: ['20.mp4', '2.mp4']\n",
+      "19: ['19.mp4']\n",
+      "4: ['4.mp4']\n"
+     ]
+    }
+   ],
+   "source": [
+    "files = {\n",
+    "    1: \"1.mp4\", 2: \"2.mp4\", 3: \"3.mp4\", 4: \"4.mp4\", 5: \"5.mp4\",\n",
+    "    6: \"6.mp4\", 7: \"7.mp4\", 8: \"8.mp4\", 9: \"9.mp4\",\n",
+    "    10: \"10.mp4\", 11: \"11.mp4\", 12: \"12.mp4\", 13: \"13.mp4\", 14: \"14.mp4\",\n",
+    "    15: \"15.mp4\", 16: \"16.mp4\", 17: \"17.mp4\", 18: \"18.mp4\", 19: \"19.mp4\",\n",
+    "    20: \"20.mp4\", 30: \"30.mp4\", 40: \"40.mp4\", 50: \"50.mp4\",\n",
+    "    60: \"60.mp4\", 70: \"70.mp4\", 80: \"80.mp4\", 90: \"90.mp4\",\n",
+    "    100: \"100.mp4\", 1000: \"1000.mp4\",\n",
+    "    100000: \"100000.mp4\"\n",
+    "}\n",
+    "\n",
+    "def number_to_clips(n):\n",
+    "    components = []\n",
+    "    if n >= 100000:\n",
+    "        lakh = n // 100000\n",
+    "        if lakh > 0:\n",
+    "            components.append(lakh)\n",
+    "            components.append(100000)\n",
+    "        n %= 100000\n",
+    "    if n >= 1000:\n",
+    "        thousand = n // 1000\n",
+    "        if thousand > 0:\n",
+    "            components.append(thousand)\n",
+    "            components.append(1000)\n",
+    "        n %= 1000\n",
+    "    if n >= 100:\n",
+    "        hundred = n // 100\n",
+    "        if hundred > 0:\n",
+    "            components.append(hundred)\n",
+    "            components.append(100)\n",
+    "        n %= 100\n",
+    "    if n > 20:\n",
+    "        tens = (n // 10) * 10\n",
+    "        if tens > 0:\n",
+    "            components.append(tens)\n",
+    "        n %= 10\n",
+    "    if n > 0:\n",
+    "        components.append(n)\n",
+    "    return components\n",
+    "\n",
+    "def generate_clip_sequence(n):\n",
+    "    components = number_to_clips(n)\n",
+    "    clip_sequence = []\n",
+    "    for component in components:\n",
+    "        if component in files:\n",
+    "            clip_sequence.append(files[component])\n",
+    "        else:\n",
+    "            # Break down further if component is not in files\n",
+    "            sub_components = number_to_clips(component)\n",
+    "            clip_sequence.extend([files[sub] for sub in sub_components])\n",
+    "    return clip_sequence\n",
+    "\n",
+    "# Example usage\n",
+    "examples = [99, 111, 256, 1000, 1011, 9999, 10000, 24256, 22, 19, 4]\n",
+    "for example in examples:\n",
+    "    print(f\"{example}: {generate_clip_sequence(example)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# code to remove first few and last few frames of clips using moviepy\n",
+    "import os\n",
+    "from moviepy.editor import VideoFileClip\n",
+    "\n",
+    "def trim_clips(clips, start=0, end=0):\n",
+    "    trimmed_clips = []\n",
+    "    for clip in clips:\n",
+    "        clip_path = os.path.join(\"clips\", clip)\n",
+    "        video = VideoFileClip(clip_path)\n",
+    "        trimmed = video.subclip(start, video.duration - end)\n",
+    "        trimmed_clips.append(trimmed)\n",
+    "    return trimmed_clips\n",
+    "\n",
+    "# Example usage\n",
+    "clips = os.listdir(\"clips\")\n",
+    "clips = [clip for clip in clips if clip.endswith(\".mp4\")]\n",
+    "\n",
+    "# Trim first 1 second and last 2 seconds\n",
+    "trimmed_clips = trim_clips(clips, 0.3, 0.3)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,4 @@
+cv
+moviepy
+opencv-python
+streamlit

trim_silence.py

@@ -0,0 +1,198 @@
+import subprocess
+import tempfile
+import sys
+import os
+import logging
+
+log_level = logging.ERROR
+log_filename = 'silence_cutter.log'
+logger = logging.getLogger('')
+logger.setLevel(log_level)
+log_handler = logging.FileHandler(log_filename, delay=True)
+logger.addHandler(log_handler)
+
+
+def findSilences(filename, dB = -25):
+  """
+    returns a list:
+      even elements (0,2,4, ...) denote silence start time
+      uneven elements (1,3,5, ...) denote silence end time
+
+  """
+  logging.debug(f"findSilences ()")
+  logging.debug(f"    - filename = {filename}")
+  logging.debug(f"    - dB = {dB}")
+
+  command = ["ffmpeg","-i",filename,
+             "-af","silencedetect=n=" + str (dB) + "dB:d=1",
+             "-f","null","-"]
+  output = subprocess.run (command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+  s = str(output)
+  lines = s.split("\\n")
+  time_list = []
+  logging.debug("  lines: ```\n" + "\n".join(lines) + "```\n\n")
+
+  for line in lines:
+    if ("silencedetect" in line):
+        words = line.split(" ")
+        logging.debug("  words: " + str(words))
+        for i in range (len(words)):
+            if ("silence_start" in words[i]):
+              time_list.append (float(words[i+1]))
+            if "silence_end" in words[i]:
+              time_list.append (float (words[i+1]))
+  silence_section_list = list (zip(*[iter(time_list)]*2))
+
+  #return silence_section_list
+  return time_list
+
+
+
+def getVideoDuration(filename:str) -> float:
+  logging.debug(f"getVideoDuration ()")
+  logging.debug(f"    - filename = {filename}")
+
+  command = ["ffprobe","-i",filename,"-v","quiet",
+             "-show_entries","format=duration","-hide_banner",
+             "-of","default=noprint_wrappers=1:nokey=1"]
+
+  output = subprocess.run (command, stdout=subprocess.PIPE)
+  s = str(output.stdout, "UTF-8")
+  return float (s)
+
+def getSectionsOfNewVideo (silences, duration):
+  """Returns timings for parts, where the video should be kept"""
+  return [0.0] + silences + [duration]
+
+
+def ffmpeg_filter_getSegmentFilter(videoSectionTimings):
+  ret = ""
+  for i in range (int (len(videoSectionTimings)/2)):
+    start = videoSectionTimings[2*i]
+    end   = videoSectionTimings[2*i+1]
+    ret += "between(t," + str(start) + "," + str(end) + ")+"
+  # cut away last "+"
+  ret = ret[:-1]
+  return ret
+
+def getFileContent_videoFilter(videoSectionTimings):
+  ret = "select='"
+  ret += ffmpeg_filter_getSegmentFilter (videoSectionTimings)
+  ret += "', setpts=N/FRAME_RATE/TB"
+  return ret
+
+def getFileContent_audioFilter(videoSectionTimings):
+  ret = "aselect='"
+  ret += ffmpeg_filter_getSegmentFilter (videoSectionTimings)
+  ret += "', asetpts=N/SR/TB"
+  return ret
+
+def writeFile (filename, content):
+  logging.debug(f"writeFile ()")
+  logging.debug(f"    - filename = {filename}")
+
+  with open (filename, "w") as file:
+    file.write (str(content))
+
+
+def ffmpeg_run (file, videoFilter, audioFilter, outfile):
+  logging.debug(f"ffmpeg_run ()")
+
+  # prepare filter files
+  vFile = tempfile.NamedTemporaryFile (mode="w", encoding="UTF-8", prefix="silence_video")
+  aFile = tempfile.NamedTemporaryFile (mode="w", encoding="UTF-8", prefix="silence_audio")
+
+  videoFilter_file = vFile.name #"/tmp/videoFilter" # TODO: replace with tempfile
+  audioFilter_file = aFile.name #"/tmp/audioFilter" # TODO: replace with tempfile
+  writeFile (videoFilter_file, videoFilter)
+  writeFile (audioFilter_file, audioFilter)
+
+  command = ["ffmpeg","-i",file,
+              "-filter_script:v",videoFilter_file,
+              "-filter_script:a",audioFilter_file,
+              outfile]
+  subprocess.run (command)
+
+  vFile.close()
+  aFile.close()
+
+
+
+def cut_silences(infile, outfile, dB = -35):
+  logging.debug(f"cut_silences ()")
+  logging.debug(f"    - infile = {infile}")
+  logging.debug(f"    - outfile = {outfile}")
+  logging.debug(f"    - dB = {dB}")
+
+  print ("detecting silences")
+  silences = findSilences (infile,dB)
+  duration = getVideoDuration (infile)
+  videoSegments = getSectionsOfNewVideo (silences, duration)
+
+  videoFilter = getFileContent_videoFilter (videoSegments)
+  audioFilter = getFileContent_audioFilter (videoSegments)
+
+  print ("create new video")
+  ffmpeg_run (infile, videoFilter, audioFilter, outfile)
+
+def printHelp():
+  print ("Usage:")
+  print ("   silence_cutter.py [infile] [optional: outfile] [optional: dB]")
+  print ("   ")
+  print ("        [outfile]")
+  print ("         Default: [infile]_cut")
+  print ("   ")
+  print ("        [dB]")
+  print ("         Default: -30")
+  print ("         A suitable value might be around -50 to -35.")
+  print ("         The lower the more volume will be defined das 'silent'")
+  print ("         -30: Cut Mouse clicks and mouse movent; cuts are very recognizable.")
+  print ("         -35: Cut inhaling breath before speaking; cuts are quite recognizable.")
+  print ("         -40: Cuts are almost not recognizable.")
+  print ("         -50: Cuts are almost not recognizable.")
+  print ("              Cuts nothing, if there is background noise.")
+  print ("         ")
+  print ("")
+  print ("Dependencies:")
+  print ("          ffmpeg")
+  print ("          ffprobe")
+
+def main():
+  logging.debug(f"main ()")
+  args = sys.argv[1:]
+  if (len(args) < 1):
+    printHelp()
+    return
+
+  if (args[0] == "--help"):
+    printHelp()
+    return
+
+  infile = args[0]
+
+  if (not os.path.isfile (infile)):
+    print ("ERROR: The infile could not be found:\n" + infile)
+    return
+
+  # set default values for optionl arguments
+  tmp = os.path.splitext (infile)
+  outfile = tmp[0] + "_cut" + tmp[1]
+  dB = -20
+
+  if (len(args) >= 2):
+    outfile = args[1]
+
+  if (len(args) >= 3):
+    dB = args[2]
+
+
+  cut_silences (infile, outfile, dB)
+
+
+if __name__ == "__main__":
+  # main()
+
+  import os
+  for file in os.listdir():
+      if file.endswith(".mp4"):
+        cut_silences(file, file.split(".mp4")[0] + "_cut.mp4", -20)

utils.py

@@ -0,0 +1,157 @@
+from moviepy.editor import VideoFileClip, concatenate_videoclips
+
+files = {
+    1: "1.mp4", 2: "2.mp4", 3: "3.mp4", 4: "4.mp4", 5: "5.mp4",
+    6: "6.mp4", 7: "7.mp4", 8: "8.mp4", 9: "9.mp4",
+    10: "10.mp4", 11: "11.mp4", 12: "12.mp4", 13: "13.mp4", 14: "14.mp4",
+    15: "15.mp4", 16: "16.mp4", 17: "17.mp4", 18: "18.mp4", 19: "19.mp4",
+    20: "20.mp4", 30: "30.mp4", 40: "40.mp4", 50: "50.mp4",
+    60: "60.mp4", 70: "70.mp4", 80: "80.mp4", 90: "90.mp4",
+    100: "100.mp4", 1000: "1000.mp4",
+    100000: "100000.mp4"
+}
+
+def number_to_clips(n):
+    components = []
+    if n >= 100000:
+        lakh = n // 100000
+        if lakh > 0:
+            components.append(lakh)
+            components.append(100000)
+        n %= 100000
+    if n >= 1000:
+        thousand = n // 1000
+        if thousand > 0:
+            components.append(thousand)
+            components.append(1000)
+        n %= 1000
+    if n >= 100:
+        hundred = n // 100
+        if hundred > 0:
+            components.append(hundred)
+            components.append(100)
+        n %= 100
+    if n > 20:
+        tens = (n // 10) * 10
+        if tens > 0:
+            components.append(tens)
+        n %= 10
+    if n > 0:
+        components.append(n)
+    return components
+
+def generate_clip_sequence(n):
+    components = number_to_clips(n)
+    clip_sequence = []
+    for component in components:
+        if component in files:
+            clip_sequence.append(files[component])
+        else:
+            # Break down further if component is not in files
+            sub_components = number_to_clips(component)
+            clip_sequence.extend([files[sub] for sub in sub_components])
+    return clip_sequence
+
+
+def trimmed_clip_path(clip):
+    return f"trimmed_clips/{clip.split('.mp4')[0]}_cut.mp4"
+
+
+def get_clip_duration(clip):
+    try:
+        clip = VideoFileClip(trimmed_clip_path(clip))
+        return clip.duration
+    except Exception as e:
+        print(f"Error loading clip {trimmed_clip_path(clip)}: {e}")
+        return 0
+    
+
+
+def cut_clip(clip, st, en):
+    """
+    Cuts the given clip from start time `st` to end time `en`.
+    """
+    return clip.subclip(st, en)
+
+
+
+def create_video(number,st, en, output_file="output.mp4"):
+    """
+    Creates a video for the given number using pre-defined video clips.
+    """
+    
+    # Special files
+    intro_file = "trimmed_clips/Intro_cut.mp4"
+    conclusion_file = "trimmed_clips/Conclusion_cut.mp4"
+
+    clips_to_combine = [intro_file]
+
+    clips = generate_clip_sequence(number)
+    for clip in clips:
+        clips_to_combine.append(trimmed_clip_path(clip))
+
+    clips_to_combine.append(conclusion_file)
+
+    # Load and combine video clips
+    video_clips = []
+    for clip_path in clips_to_combine:
+        try:
+            clip = VideoFileClip(clip_path)
+            clip = cut_clip(clip, st, clip.duration - en)
+            video_clips.append(clip)
+        except Exception as e:
+            print(f"Error loading clip {clip_path}: {e}")
+
+    # Concatenate the video clips
+    if video_clips:
+        final_video = concatenate_videoclips(video_clips)
+        final_video.write_videofile(output_file, codec="libx264", audio_codec="aac")
+    else:
+        print("No clips to combine. Video creation failed.")
+
+
+def create_advanced_video(number, trim_settings, output_file="output.mp4"):
+    intro_file = "trimmed_clips/Intro_cut.mp4"
+    conclusion_file = "trimmed_clips/Conclusion_cut.mp4"
+
+    clips_to_combine = [intro_file]
+    clips = generate_clip_sequence(number)
+
+    video_clips = []
+    for i, clip_path in enumerate(clips):
+        try:
+            clip = VideoFileClip(trimmed_clip_path(clip_path))
+            trim_start, trim_end = trim_settings[i]
+            trimmed_clip = cut_clip(clip, trim_start, clip.duration - trim_end)
+            video_clips.append(trimmed_clip)
+        except Exception as e:
+            print(f"Error loading clip {clip_path}: {e}")
+
+    clips_to_combine.extend(video_clips)
+    clips_to_combine.append(conclusion_file)
+
+    if video_clips:
+        final_video = concatenate_videoclips(video_clips)
+        final_video.write_videofile(output_file, codec="libx264", audio_codec="aac")
+    else:
+        print("No clips to combine. Video creation failed.")
+
+# def main():
+#     """
+#     Main function to repeatedly prompt user input and generate videos.
+#     """
+#     while True:
+#         try:
+#             number = int(input("Enter a number between 1 and 9999999 (or 0 to exit): "))
+#             if number == 0:
+#                 print("Exiting...")
+#                 break
+#             elif number < 1 or number > 9999999:
+#                 print("Invalid input. Please enter a number between 1 and 9999999.")
+#                 continue
+#             create_video(number)
+#         except ValueError:
+#             print("Invalid input. Please enter a valid number.")
+
+# if __name__ == "__main__":
+#     main()