chore: Add .gitignore and requirements.txt files

.gitignore

@@ -0,0 +1,6 @@
+.venv
+audio
+output
+*.mp3
+*.wav
+*.mp4

appsscript.json

@@ -0,0 +1,19 @@
+{
+  "timeZone": "America/New_York",
+  "dependencies": {
+    "enabledAdvancedServices": [
+      {
+        "userSymbol": "YouTube",
+        "version": "v3",
+        "serviceId": "youtube"
+      }
+    ]
+  },
+  "oauthScopes": [
+    "https://www.googleapis.com/auth/drive",
+    "https://www.googleapis.com/auth/script.external_request",
+    "https://www.googleapis.com/auth/youtube"
+  ],
+  "exceptionLogging": "STACKDRIVER",
+  "runtimeVersion": "V8"
+}

client_secrets.json

@@ -0,0 +1,9 @@
+{
+  "web": {
+    "client_id": "672725064244-vqnm51a5ivbm6cnlbsl2mmk71k7243b5.apps.googleusercontent.com",
+    "client_secret": "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",
+    "redirect_uris": [],
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://accounts.google.com/o/oauth2/token"
+  }
+}

fonts.py

@@ -0,0 +1,35 @@
+import cv2
+import numpy as np
+
+# Create a black image
+image = np.zeros((480, 640, 3), dtype="uint8")
+
+# Text to be added
+text = "OpenCV Fonts"
+
+# Coordinates
+org = (50, 230)
+
+# Font color
+color = (255, 255, 255)  # White
+
+# Using different fonts
+fonts = [
+    cv2.FONT_HERSHEY_SIMPLEX,
+    cv2.FONT_HERSHEY_PLAIN,
+    cv2.FONT_HERSHEY_DUPLEX,
+    cv2.FONT_HERSHEY_COMPLEX,
+    cv2.FONT_HERSHEY_TRIPLEX,
+    cv2.FONT_HERSHEY_COMPLEX_SMALL,
+    cv2.FONT_HERSHEY_SCRIPT_SIMPLEX,
+    cv2.FONT_HERSHEY_SCRIPT_COMPLEX
+]
+
+# Display text using different fonts
+for i, font in enumerate(fonts):
+    cv2.putText(image, f"{text} {i+1}", (10, 30 + i*50), font, 1, color, 2)
+
+# Show the image
+cv2.imshow("OpenCV Fonts Example", image)
+cv2.waitKey(0)
+cv2.destroyAllWindows()

main.py

@@ -0,0 +1,402 @@
+import requests
+import praw
+import json
+import cv2
+import numpy as np
+import textwrap
+from gtts import gTTS
+from pydub import AudioSegment
+import subprocess
+import re
+import os
+import random
+import time
+import sys
+import uuid
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from googleapiclient.http import MediaFileUpload
+from oauth2client.client import flow_from_clientsecrets
+from oauth2client.file import Storage
+from oauth2client.tools import run_flow
+from google.auth.transport.requests import Request
+
+# Define the output folder path
+output_folder = 'output'
+
+# Constants
+SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
+CLIENT_SECRETS_FILE = "client_secrets.json" # Update with your client_secrets.json file path
+YOUTUBE_UPLOAD_SCOPE = "https://www.googleapis.com/auth/youtube.upload"
+DRIVE_SCOPE = "https://www.googleapis.com/auth/drive"
+YOUTUBE_API_SERVICE_NAME = "youtube"
+YOUTUBE_API_VERSION = "v3"
+MAX_RETRIES = 10
+RETRIABLE_STATUS_CODES = [500, 502, 503, 504]
+ELEVENLABS_KEY = "55bfc10fb7eecae379f73e6740807101"
+
+# Check if the folder exists, if not, create it
+if not os.path.exists(output_folder):
+    os.makedirs(output_folder)
+
+banned_words = ["fuck", "pussy", "ass", "porn", "gay", "dick", "cock", "kill", "fucking", "shit", "bitch", "bullshit", "asshole","douchebag", "bitch", "motherfucker", "nigga","cunt", "whore", "piss", "shoot", "bomb", "palestine", "israel" ]
+
+def contains_banned_word(text, banned_words):
+    for word in banned_words:
+        if word in text.lower():
+            return True
+    return False
+
+def fetch_reddit_data(subreddit_name):
+    # Reddit API Credentials
+    client_id = 'TIacEazZS9FHWzDZ3T-3cA'
+    client_secret = '6Urwdiqo_cC8Gt040K_rBhnR3r8CLg'
+    user_agent = 'script by u/lakpriya1'
+
+    # Initialize PRAW with your credentials
+    reddit = praw.Reddit(client_id=client_id, client_secret=client_secret, user_agent=user_agent)
+
+    subreddit = reddit.subreddit(subreddit_name)
+
+    for _ in range(10):  # Limit the number of attempts to 10
+        post = subreddit.random()
+        # Check if the title contains a pattern resembling a URL
+        if post and not re.search(r'\w+\.\w+', post.title) and not contains_banned_word(post.title, banned_words) and not len(post.title) < 50:
+            post_data = {'title': post.title}
+
+            with open('top_post.json', 'w') as outfile:
+                json.dump(post_data, outfile, indent=4)
+
+            print("Top post data saved to top_post.json")
+            return  # Exit after finding a suitable post
+
+    print("No suitable post found without a URL-like string in the title.")
+
+def read_json(filename):
+    print("Reading data from", filename)
+    with open(filename, 'r') as file:
+        data = json.load(file)
+    return data
+
+def wrap_text(text, wrap_width):
+    return textwrap.wrap(text, width=wrap_width)
+
+def resize_background_image(image_path, frame_width, frame_height):
+    print("Resizing background image")
+    image = cv2.imread(image_path)
+    h, w = image.shape[:2]
+    scale = max(frame_width / w, frame_height / h)
+    new_w, new_h = int(w * scale), int(h * scale)
+    resized_image = cv2.resize(image, (new_w, new_h))
+
+    # Cropping the resized image to fill the frame
+    startx = new_w // 2 - (frame_width // 2)
+    starty = new_h // 2 - (frame_height // 2)
+    cropped_image = resized_image[starty:starty+frame_height, startx:startx+frame_width]
+    return cropped_image
+
+def put_text_with_stroke(frame, text, position, font_scale, line_height, wrap_width, font_color=(255, 255, 255), stroke_color=(0, 0, 0)):
+    font = cv2.FONT_HERSHEY_COMPLEX
+    lines = wrap_text(text, wrap_width)
+
+    # Calculate the total height of the text block
+    total_text_height = line_height * len(lines)
+
+    # Starting Y position to center text vertically
+    start_y = (frame.shape[0] - total_text_height) // 2
+
+    for line in lines:
+        text_size = cv2.getTextSize(line, font, font_scale, 1)[0]
+        # Calculate x coordinate for center alignment
+        text_x = (frame.shape[1] - text_size[0]) // 2
+        text_y = start_y + line_height
+
+        # Draw text stroke (increase thickness for a bolder stroke)
+        cv2.putText(frame, line, (text_x, text_y), font, font_scale, stroke_color, 8, cv2.LINE_AA)
+
+        # Draw original text on top
+        cv2.putText(frame, line, (text_x, text_y), font, font_scale, font_color, 2, cv2.LINE_AA)
+
+        start_y += line_height
+
+def create_video_from_title(title, background_image, output_filename, audio_duration):
+    print("Creating video from title")
+    # Video properties
+    fps = 24
+    frame_width, frame_height = 720, 1280  # 9:16 aspect ratio
+    frame_count = audio_duration * fps
+
+    # Logo images
+    top_logo = load_logo('logo.png', frame_width, frame_height, 'top')
+    bottom_logo = load_logo('sub.png', frame_width, frame_height, 'bottom')
+
+    # OpenCV VideoWriter
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_filename, fourcc, fps, (frame_width, frame_height))
+
+    # Resize the background image
+    background = resize_background_image(background_image, frame_width, frame_height)
+
+    for i in range(int(np.floor(frame_count))):
+        frame = background.copy()  # Use the resized background image
+
+        # Overlay logos
+        frame = overlay_logo(frame, top_logo)
+        frame = overlay_logo(frame, bottom_logo)
+
+        # Add title to frame with text wrapping and highlight
+        put_text_with_stroke(frame, title, (50, 500), 1, 50, 25, font_color=(255, 255, 255), stroke_color=(0, 0, 0))  # Adjust wrap_width and line_height as needed
+
+        out.write(frame)  # Write the frame to the video
+
+    out.release()
+
+def fetch_random_nature_image(api_key):
+    print("Fetching random nature image from Unsplash")
+    url = f"https://api.unsplash.com/photos/random?query=nature&client_id={api_key}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        img_url = response.json()['urls']['regular']
+        img_data = requests.get(img_url).content
+        with open('nature_background.jpg', 'wb') as handler:
+            handler.write(img_data)
+        return 'nature_background.jpg'
+    else:
+        print("Failed to fetch image from Unsplash")
+        return None
+    
+def text_to_speech(text, output_file):
+    print("Converting text to speech")
+    tts = gTTS(text=text, lang='en')
+    tts.save(output_file)
+    return output_file
+
+def get_audio_duration(audio_file):
+    print("Getting audio duration")
+    audio = AudioSegment.from_mp3(audio_file)
+    return len(audio) / 1000.0  # Convert to seconds
+
+def combine_audio_video(video_file, audio_file, output_file, audio_delay_seconds=0.3):
+    # Construct the full path for the output file
+    output_file = os.path.join(output_folder, output_file)
+
+    # Add a delay to the audio start
+    cmd = f'ffmpeg -i "{video_file}" -itsoffset {audio_delay_seconds} -i "{audio_file}" -c:v copy -c:a aac -strict experimental -map 0:v:0 -map 1:a:0 "{output_file}"'
+    subprocess.call(cmd, shell=True)
+    print("Successfully made the video:", output_file)
+
+def load_logo(logo_path, frame_width, frame_height, position='top'):
+    logo = cv2.imread(logo_path, cv2.IMREAD_UNCHANGED)  # Load with alpha channel
+    logo_height, logo_width = logo.shape[:2]
+
+    # Scaling down the logo if it's too big
+    scale_factor = min(1, frame_width / 3 / logo_width, frame_height / 10 / logo_height)
+    new_size = (int(logo_width * scale_factor*1.3), int(logo_height * scale_factor*1.3))
+    logo = cv2.resize(logo, new_size, interpolation=cv2.INTER_AREA)
+
+    # Positioning
+    x_center = frame_width // 2 - logo.shape[1] // 2
+    if position == 'top':
+        y_pos = 100  # 10 pixels from the top
+    else:  # 'bottom'
+        y_pos = frame_height - logo.shape[0] - 100  # 10 pixels from the bottom
+
+    return logo, (x_center, y_pos)
+
+def overlay_logo(frame, logo_info):
+    logo, (x, y) = logo_info
+    y1, y2 = y, y + logo.shape[0]
+    x1, x2 = x, x + logo.shape[1]
+
+    if logo.shape[2] == 4:  # If the logo has an alpha channel
+        alpha_logo = logo[:, :, 3] / 255.0
+        alpha_frame = 1.0 - alpha_logo
+        for c in range(0, 3):
+            frame[y1:y2, x1:x2, c] = (alpha_logo * logo[:, :, c] +
+                                      alpha_frame * frame[y1:y2, x1:x2, c])
+    else:  # If the logo does not have an alpha channel
+        frame[y1:y2, x1:x2] = logo
+
+    return frame
+
+def get_authenticated_service():
+    flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=YOUTUBE_UPLOAD_SCOPE)
+    storage = Storage(f"{sys.argv[0]}-oauth2.json")
+    credentials = storage.get()
+    if credentials is None or credentials.invalid:
+        credentials = run_flow(flow, storage)
+    return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, credentials=credentials)
+
+def upload_video_to_drive(video_file, folder_id=None):
+    """Uploads a video to Google Drive."""
+    # Check if the credentials are stored
+    storage = Storage(f"{sys.argv[0]}-oauth2.json")
+    credentials = storage.get()
+
+    # If credentials are not available or are invalid, run the flow
+    if not credentials or credentials.invalid:
+        flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=[DRIVE_SCOPE])
+        credentials = run_flow(flow, storage)
+
+    service = build('drive', 'v3', credentials=credentials)
+
+    file_metadata = {
+        'name': os.path.basename(video_file),
+        'mimeType': 'video/mp4'
+    }
+    if folder_id:
+        file_metadata['parents'] = [folder_id]
+
+    media = MediaFileUpload(video_file, mimetype='video/mp4', resumable=True)
+    file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
+    
+    print('File ID: %s' % file.get('id'))
+
+def initialize_upload(youtube, options):
+    tags = None
+    if 'keywords' in options and options['keywords']:
+        tags = options['keywords'].split(",")
+
+    body = dict(
+        snippet=dict(
+            title=options['title'],
+            description=options['description'],
+            tags=tags,
+            categoryId=options['category']
+        ),
+        status=dict(
+            privacyStatus=options['privacyStatus']
+        )
+    )
+
+    # Call the API's videos.insert method to create and upload the video.
+    insert_request = youtube.videos().insert(
+    part=",".join(body.keys()),
+    body=body,
+    # The chunksize parameter specifies the size of each chunk of data, in
+    # bytes, that will be uploaded at a time. Set a higher value for
+    # reliable connections as fewer chunks lead to faster uploads. Set a lower
+    # value for better recovery on less reliable connections.
+    #
+    # Setting "chunksize" equal to -1 in the code below means that the entire
+    # file will be uploaded in a single HTTP request. (If the upload fails,
+    # it will still be retried where it left off.) This is usually a best
+    # practice, but if you're using Python older than 2.6 or if you're
+    # running on App Engine, you should set the chunksize to something like
+    # 1024 * 1024 (1 megabyte).
+    media_body=MediaFileUpload(options["file"], chunksize=-1, resumable=True)
+    )
+
+    resumable_upload(insert_request)
+
+# This method implements an exponential backoff strategy to resume a
+# failed upload.
+def resumable_upload(insert_request):
+  response = None
+  error = None
+  retry = 0
+  while response is None:
+    try:
+      print("Uploading file...")
+      status, response = insert_request.next_chunk()
+      if response is not None:
+        if 'id' in response:
+          print("Video id '%s' was successfully uploaded." % response['id'])
+        else:
+          exit("The upload failed with an unexpected response: %s" % response)
+    except HttpError as e:
+      if e.resp.status in RETRIABLE_STATUS_CODES:
+        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
+                                                             e.content)
+      else:
+        raise
+    # except RETRIABLE_EXCEPTIONS as e:
+    #   error = "A retriable error occurred: %s" % e
+
+    if error is not None:
+      print(error)
+      retry += 1
+      if retry > MAX_RETRIES:
+        exit("No longer attempting to retry.")
+
+      max_sleep = 2 ** retry
+      sleep_seconds = random.random() * max_sleep
+      print("Sleeping %f seconds and then retrying..." % sleep_seconds)
+      time.sleep(sleep_seconds)
+
+def eleven_labs_text_to_speech(text, output_file):
+    voice_ids = {
+        "ndntWUKwYjgJGYkvF6at",
+        "SVLJSgUbrKWfY8HvF2Xd",
+        "sjdiTCylizqR74A3ssv4",
+    }
+    # randomly pick one of the voices
+    voice_id = random.choice(list(voice_ids))
+    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+    
+    headers = {
+        "Accept": "audio/mpeg",
+        "Content-Type": "application/json",
+        "xi-api-key": ELEVENLABS_KEY
+    }
+
+    data = {
+        "text": text,
+        "model_id": "eleven_monolingual_v1",
+        "voice_settings": {
+            "stability": 0.5,
+            "similarity_boost": 0.5,
+            "speed": 0.3,
+        }
+    }
+
+    response = requests.post(url, json=data, headers=headers)
+    if response.status_code == 200:
+        with open(output_file, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=1024):
+                f.write(chunk)
+        print(f"Audio content written to {output_file}")
+    else:
+        print(f"Failed to synthesize speech: {response.content}")
+
+api_key = 'VhLwkCKi3iu5Pf37LXfz-Lp7hTW69EV8uw_hkLAPkiA'  # Replace with your Unsplash API key
+background_image = fetch_random_nature_image(api_key)
+
+if background_image:
+    # Example usage
+    fetch_reddit_data('Glitch_in_the_Matrix')
+
+    # Read data from JSON
+    reddit_data = read_json('top_post.json')  # Change filename if needed
+    title = reddit_data.get('title')
+
+    filename = "video_" + str(uuid.uuid4())
+
+    # Convert text to speech
+    # voiceover_file = text_to_speech(title, 'voiceover.mp3')
+    voiceover_file = eleven_labs_text_to_speech(title, 'voiceover.mp3')
+
+    # Get audio duration
+    audio_duration = get_audio_duration('voiceover.mp3')
+
+    # Create and save the video
+    create_video_from_title(title, background_image, "reddit_post_video_cv2.mp4", audio_duration)
+
+    # Combine audio and video
+    combine_audio_video('reddit_post_video_cv2.mp4', 'voiceover.mp3', filename + '.mp4')
+
+    options = {
+        'file': 'output/'+ filename + '.mp4',
+        'title': "Amazing Facts Revealed: Unveiling the World's Hidden Wonders #shorts",
+        'description':  "Welcome to our latest YouTube video, 'Amazing Facts Revealed: Unveiling the World's Hidden Wonders'! In this enthralling episode, we dive deep into the most astonishing and lesser-known facts about our world. From the mysteries of the deep sea to the enigmas of outer space, we cover it all. Get ready to be amazed by incredible scientific discoveries, historical secrets, and mind-blowing natural phenomena. Each fact is meticulously researched and presented with stunning visuals and engaging narration. Don't forget to like, share, and subscribe for more fascinating content. Stay curious and let's explore the wonders of our world together #shorts",
+        'category': "22",
+        'keywords': "facts, shorts, funny",
+        'privacyStatus': "private"
+    }
+
+    # try:
+        # youtube = get_authenticated_service()
+        # initialize_upload(youtube, options)
+    #     upload_video_to_drive('output/'+ filename + '.mp4','1t2lcYNLgz6FTeabzccY_06rvcnTGdQiR')
+    # except HttpError as e:
+    #     print("An HTTP error %d occurred:\n%s" % (e.resp.status, e.content))

main.py-oauth2.json

@@ -0,0 +1,24 @@
+{
+  "access_token": "ya29.a0AfB_byCOgc6o05Gy2sr--ly9q-fu1pasaHdO7sf99mc9QMZckk5gD_FIT7lJXjQ3Nl7Ak2YEwwlPqkQ1NjHw5qDEU96pCjOrz1cWgwLQowkP9Pu2VGDSdrrioKUVfGLezq7XhF-9YY08DR9iQhLZkh_EDAPLV5t4Pbz0aCgYKATcSARESFQHGX2MiIcRo1PRx2TYi8IC3A5vfJQ0171",
+  "client_id": "672725064244-vqnm51a5ivbm6cnlbsl2mmk71k7243b5.apps.googleusercontent.com",
+  "client_secret": "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",
+  "refresh_token": "1//0gpokRv3uQZF0CgYIARAAGBASNwF-L9IrwQ6moxZWlGx_tKdcbT2QMKp2LMQRoBMCRMKk5Gp3cLFasTMoYF9SI30il7hG3giukTY",
+  "token_expiry": "2024-01-28T20:19:41Z",
+  "token_uri": "https://accounts.google.com/o/oauth2/token",
+  "user_agent": null,
+  "revoke_uri": "https://oauth2.googleapis.com/revoke",
+  "id_token": null,
+  "id_token_jwt": null,
+  "token_response": {
+    "access_token": "ya29.a0AfB_byCOgc6o05Gy2sr--ly9q-fu1pasaHdO7sf99mc9QMZckk5gD_FIT7lJXjQ3Nl7Ak2YEwwlPqkQ1NjHw5qDEU96pCjOrz1cWgwLQowkP9Pu2VGDSdrrioKUVfGLezq7XhF-9YY08DR9iQhLZkh_EDAPLV5t4Pbz0aCgYKATcSARESFQHGX2MiIcRo1PRx2TYi8IC3A5vfJQ0171",
+    "expires_in": 3599,
+    "refresh_token": "1//0gpokRv3uQZF0CgYIARAAGBASNwF-L9IrwQ6moxZWlGx_tKdcbT2QMKp2LMQRoBMCRMKk5Gp3cLFasTMoYF9SI30il7hG3giukTY",
+    "scope": "https://www.googleapis.com/auth/youtube.upload",
+    "token_type": "Bearer"
+  },
+  "scopes": ["https://www.googleapis.com/auth/youtube.upload"],
+  "token_info_uri": "https://oauth2.googleapis.com/tokeninfo",
+  "invalid": false,
+  "_class": "OAuth2Credentials",
+  "_module": "oauth2client.client"
+}

main_glitch.py

@@ -0,0 +1,562 @@
+import requests
+import praw
+import json
+import cv2
+import numpy as np
+import textwrap
+from gtts import gTTS
+from pydub import AudioSegment
+import subprocess
+import re
+import os
+import random
+import time
+import sys
+import uuid
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from googleapiclient.http import MediaFileUpload
+from oauth2client.client import flow_from_clientsecrets
+from oauth2client.file import Storage
+from oauth2client.tools import run_flow
+from google.auth.transport.requests import Request
+import nltk
+from tts import synthesiser, speaker_embedding 
+import soundfile as sf
+
+# from tortoise_tts import TextToSpeech
+
+# nltk.download('punkt')
+
+# Define the output folder path
+output_folder = 'output'
+
+# Constants
+SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
+CLIENT_SECRETS_FILE = "client_secrets.json" # Update with your client_secrets.json file path
+YOUTUBE_UPLOAD_SCOPE = "https://www.googleapis.com/auth/youtube.upload"
+DRIVE_SCOPE = "https://www.googleapis.com/auth/drive"
+YOUTUBE_API_SERVICE_NAME = "youtube"
+YOUTUBE_API_VERSION = "v3"
+MAX_RETRIES = 10
+RETRIABLE_STATUS_CODES = [500, 502, 503, 504]
+ELEVENLABS_KEY = "153f3875b30f603644cc66a78f1345ea"
+
+# Check if the folder exists, if not, create it
+if not os.path.exists(output_folder):
+    os.makedirs(output_folder)
+
+banned_words = ["fuck", "pussy", "ass", "porn", "gay", "dick", "cock", "kill", "fucking", "shit", "bitch", "bullshit", "asshole","douchebag", "bitch", "motherfucker", "nigga","cunt", "whore", "piss", "shoot", "bomb", "palestine", "israel" ]
+
+def contains_banned_word(text, banned_words):
+    for word in banned_words:
+        if word in text.lower():
+            return True
+    return False
+
+def fetch_reddit_data(subreddit_name):
+    # Reddit API Credentials
+    client_id = 'TIacEazZS9FHWzDZ3T-3cA'
+    client_secret = '6Urwdiqo_cC8Gt040K_rBhnR3r8CLg'
+    user_agent = 'script by u/lakpriya1'
+
+    # Initialize PRAW with your credentials
+    reddit = praw.Reddit(client_id=client_id, client_secret=client_secret, user_agent=user_agent)
+
+    subreddit = reddit.subreddit(subreddit_name)
+
+    for _ in range(10):  # Limit the number of attempts to 10
+        post = subreddit.random()
+        # Check if the title contains a pattern resembling a URL
+        if post and not re.search(r'\w+\.\w+', post.selftext) and not contains_banned_word(post.selftext, banned_words) and not len(post.selftext) < 50:
+            post_data = {'title': post.title, 'selftext': post.selftext}
+
+            with open('top_post.json', 'w') as outfile:
+                json.dump(post_data, outfile, indent=4)
+
+            print("Top post data saved to top_post.json")
+            return  # Exit after finding a suitable post
+
+    print("No suitable post found without a URL-like string in the title.")
+
+def read_json(filename):
+    print("Reading data from", filename)
+    with open(filename, 'r') as file:
+        data = json.load(file)
+    return data
+
+def wrap_text(text, wrap_width):
+    return textwrap.wrap(text, width=wrap_width)
+
+def resize_background_image(image_path, frame_width, frame_height):
+    print("Resizing background image")
+    image = cv2.imread(image_path)
+    h, w = image.shape[:2]
+    scale = max(frame_width / w, frame_height / h)
+    new_w, new_h = int(w * scale), int(h * scale)
+    resized_image = cv2.resize(image, (new_w, new_h))
+
+    # Cropping the resized image to fill the frame
+    startx = new_w // 2 - (frame_width // 2)
+    starty = new_h // 2 - (frame_height // 2)
+    cropped_image = resized_image[starty:starty+frame_height, startx:startx+frame_width]
+    return cropped_image
+
+def put_text_with_stroke(frame, texts, positions, font_scales, line_heights, wrap_widths, font_colors=(255, 255, 255), stroke_colors=(0, 0, 0), fonts=None):
+    default_font = cv2.FONT_HERSHEY_COMPLEX
+    if fonts is None:
+        fonts = [default_font] * len(texts)  # Use default font if not specified
+
+    for text, position, font_scale, line_height, wrap_width, font_color, stroke_color, font in zip(texts, positions, font_scales, line_heights, wrap_widths, font_colors, stroke_colors, fonts):
+        lines = wrap_text(text, wrap_width)
+
+        # Calculate the total height of the text block
+        total_text_height = line_height * len(lines)
+
+        # Starting Y position to center text vertically
+        if position[1] is None:
+            start_y = (frame.shape[0] - total_text_height) // 2 + 100
+        else:
+            start_y = position[1]
+
+        for line in lines:
+            text_size = cv2.getTextSize(line, font, font_scale, 1)[0]
+            text_x = position[0] - text_size[0] // 2
+            text_y = start_y + line_height
+
+            cv2.putText(frame, line, (text_x, text_y), font, font_scale, stroke_color, 8, cv2.LINE_AA)
+            cv2.putText(frame, line, (text_x, text_y), font, font_scale, font_color, 2, cv2.LINE_AA)
+
+            start_y += line_height
+
+# def create_video_from_title(title, background_image, output_filename, audio_duration):
+#     print("Creating video from title")
+#     # Video properties
+#     fps = 24
+#     frame_width, frame_height = 720, 1280  # 9:16 aspect ratio
+#     frame_count = audio_duration * fps
+
+#     # Logo images
+#     top_logo = load_logo('logo.png', frame_width, frame_height, 'top')
+#     bottom_logo = load_logo('sub.png', frame_width, frame_height, 'bottom')
+
+#     # OpenCV VideoWriter
+#     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+#     out = cv2.VideoWriter(output_filename, fourcc, fps, (frame_width, frame_height))
+
+#     # Resize the background image
+#     background = resize_background_image(background_image, frame_width, frame_height)
+
+#     for i in range(int(np.floor(frame_count))):
+#         frame = background.copy()  # Use the resized background image
+
+#         # Overlay logos
+#         frame = overlay_logo(frame, top_logo)
+#         frame = overlay_logo(frame, bottom_logo)
+
+#         # Add title to frame with text wrapping and highlight
+#         put_text_with_stroke(frame, title, (50, 500), 1, 50, 25, font_color=(255, 255, 255), stroke_color=(0, 0, 0))  # Adjust wrap_width and line_height as needed
+
+#         out.write(frame)  # Write the frame to the video
+
+#     out.release()
+
+def create_video_from_title(title, sentences, background_image, output_filename, audio_durations):
+    print("Creating video from title")
+    fps = 24
+    frame_width, frame_height = 720, 1280  # 9:16 aspect ratio
+
+    # OpenCV VideoWriter
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_filename, fourcc, fps, (frame_width, frame_height))
+
+     # Logo images
+    top_logo = load_logo('G.png', frame_width, frame_height, 'top')
+    bottom_logo = load_logo('follow.png', frame_width, frame_height, 'bottom')
+
+    # Resize the background image
+    background = resize_background_image(background_image, frame_width, frame_height)
+
+    # Define font settings for title and sentence
+    title_font = cv2.FONT_HERSHEY_TRIPLEX
+    sentence_font = cv2.FONT_HERSHEY_TRIPLEX
+    title_font_scale = 1.5  # Larger font for the title
+    sentence_font_scale = 1.2  # Normal font for the sentence
+    title_line_height = 50
+    sentence_line_height = 50
+
+    # Font color as white
+    white_color = (255, 255, 255)  # BGR color code for white
+    stroke_color = (0, 0, 0)  # BGR color code for black
+
+    title = preprocess_text(title)
+
+    current_frame = 0
+    for sentence, duration in zip(sentences, audio_durations):
+        sentence_frames = int(duration * fps)
+        for i in range(sentence_frames):
+            frame = background.copy()
+
+                 # Overlay logos
+            frame = overlay_logo(frame, top_logo)
+            frame = overlay_logo(frame, bottom_logo)
+
+            # Position for title and sentence
+            title_position = (frame_width // 2, frame_height // 4)  # Title at the top
+            sentence_position = (frame_width // 2, None)  # Sentence at the center
+
+            sentence = preprocess_text(sentence)
+
+            # Add title and sentence to frame with specific fonts, sizes, and colors
+            put_text_with_stroke(frame, 
+                                 [title, sentence], 
+                                 [title_position, sentence_position], 
+                                 [title_font_scale, sentence_font_scale], 
+                                 [title_line_height, sentence_line_height], 
+                                 [25, 25], 
+                                 font_colors=[white_color, white_color], 
+                                 stroke_colors=[stroke_color, stroke_color], 
+                                 fonts=[title_font, sentence_font])
+
+            out.write(frame)
+            current_frame += 1
+
+    out.release()
+
+
+def tts_per_sentence(sentences, output_folder, silence_duration=1000):
+    audio_durations = []
+    audio_files = []
+
+    for index, sentence in enumerate(sentences):
+        output_file = f'{output_folder}/voiceover_{index}.wav'
+        text_to_speech_using_speecht5(sentence, output_file)
+        audio = AudioSegment.from_wav(output_file)
+        silence = AudioSegment.silent(duration=silence_duration)
+        audio_with_silence = audio + silence
+        audio_with_silence.export(output_file, format="wav")
+        audio_duration = len(audio_with_silence) / 1000.0  
+        audio_durations.append(audio_duration)
+        audio_files.append(output_file)
+    return audio_files, audio_durations
+
+# def eleven_labs_text_to_speech(text, output_file, voice_id):
+#     url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+    
+#     headers = {
+#         "Accept": "audio/mpeg",
+#         "Content-Type": "application/json",
+#         "xi-api-key": ELEVENLABS_KEY
+#     }
+
+#     data = {
+#         "text": text,
+#         "model_id": "eleven_monolingual_v1",
+#         "voice_settings": {
+#             "stability": 0.5,
+#             "similarity_boost": 0.5,
+#             "speed": 0.3,
+#         }
+#     }
+
+#     response = requests.post(url, json=data, headers=headers)
+#     if response.status_code == 200:
+#         with open(output_file, 'wb') as f:
+#             for chunk in response.iter_content(chunk_size=1024):
+#                 f.write(chunk)
+#         print(f"Audio content written to {output_file}")
+#     else:
+#         print(f"Failed to synthesize speech: {response.content}")
+
+def text_to_speech_using_speecht5(text, output_file): 
+    # Use the synthesiser from tts.py
+    speech = synthesiser(text, forward_params={"speaker_embeddings": speaker_embedding})
+    sf.write(output_file, speech["audio"], samplerate=speech["sampling_rate"])
+    print(f"Audio content written to {output_file}")
+
+def fetch_random_nature_image(api_key):
+    print("Fetching random nature image from Unsplash")
+    url = f"https://api.unsplash.com/photos/random?query=horror&client_id={api_key}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        img_url = response.json()['urls']['regular']
+        img_data = requests.get(img_url).content
+        with open('nature_background.jpg', 'wb') as handler:
+            handler.write(img_data)
+        return 'nature_background.jpg'
+    else:
+        print("Failed to fetch image from Unsplash")
+        return None
+    
+def preprocess_text(text):
+    # Replace Unicode right single quotation mark with ASCII apostrophe
+    text = text.replace('\u2019', "'")
+    # If there are other specific characters causing issues, replace them similarly
+    return text
+    
+def text_to_speech(text, output_file):
+    print("Converting text to speech")
+    tts = gTTS(text=text, lang='en')
+    tts.save(output_file)
+    return output_file
+
+def get_audio_duration(audio_file):
+    print("Getting audio duration")
+    audio = AudioSegment.from_mp3(audio_file)
+    return len(audio) / 1000.0  # Convert to seconds
+
+def combine_audio_video(video_file, audio_file, output_file, audio_delay_seconds=0.3):
+    # Construct the full path for the output file
+    output_file = os.path.join(output_folder, output_file)
+
+    # Add a delay to the audio start
+    cmd = f'ffmpeg -i "{video_file}" -itsoffset {audio_delay_seconds} -i "{audio_file}" -c:v copy -c:a aac -strict experimental -map 0:v:0 -map 1:a:0 "{output_file}"'
+    subprocess.call(cmd, shell=True)
+    print("Successfully made the video:", output_file)
+
+def load_logo(logo_path, frame_width, frame_height, position='top'):
+    logo = cv2.imread(logo_path, cv2.IMREAD_UNCHANGED)  # Load with alpha channel
+    logo_height, logo_width = logo.shape[:2]
+
+    # Scaling down the logo if it's too big
+    scale_factor = min(1, frame_width / 3 / logo_width, frame_height / 10 / logo_height)
+    new_size = (int(logo_width * scale_factor*1.3), int(logo_height * scale_factor*1.3))
+    logo = cv2.resize(logo, new_size, interpolation=cv2.INTER_AREA)
+
+    # Positioning
+    x_center = frame_width // 2 - logo.shape[1] // 2
+    if position == 'top':
+        y_pos = 100  # 10 pixels from the top
+    else:  # 'bottom'
+        y_pos = frame_height - logo.shape[0] - 100  # 10 pixels from the bottom
+
+    return logo, (x_center, y_pos)
+
+def overlay_logo(frame, logo_info):
+    logo, (x, y) = logo_info
+    y1, y2 = y, y + logo.shape[0]
+    x1, x2 = x, x + logo.shape[1]
+
+    if logo.shape[2] == 4:  # If the logo has an alpha channel
+        alpha_logo = logo[:, :, 3] / 255.0
+        alpha_frame = 1.0 - alpha_logo
+        for c in range(0, 3):
+            frame[y1:y2, x1:x2, c] = (alpha_logo * logo[:, :, c] +
+                                      alpha_frame * frame[y1:y2, x1:x2, c])
+    else:  # If the logo does not have an alpha channel
+        frame[y1:y2, x1:x2] = logo
+
+    return frame
+
+def get_authenticated_service():
+    flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=YOUTUBE_UPLOAD_SCOPE)
+    storage = Storage(f"{sys.argv[0]}-oauth2.json")
+    credentials = storage.get()
+    if credentials is None or credentials.invalid:
+        credentials = run_flow(flow, storage)
+    return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION, credentials=credentials)
+
+def upload_video_to_drive(video_file, folder_id=None):
+    """Uploads a video to Google Drive."""
+    # Check if the credentials are stored
+    storage = Storage(f"{sys.argv[0]}-oauth2.json")
+    credentials = storage.get()
+
+    # If credentials are not available or are invalid, run the flow
+    if not credentials or credentials.invalid:
+        flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=[DRIVE_SCOPE])
+        credentials = run_flow(flow, storage)
+
+    service = build('drive', 'v3', credentials=credentials)
+
+    file_metadata = {
+        'name': os.path.basename(video_file),
+        'mimeType': 'video/mp4'
+    }
+    if folder_id:
+        file_metadata['parents'] = [folder_id]
+
+    media = MediaFileUpload(video_file, mimetype='video/mp4', resumable=True)
+    file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
+    
+    print('File ID: %s' % file.get('id'))
+
+def initialize_upload(youtube, options):
+    tags = None
+    if 'keywords' in options and options['keywords']:
+        tags = options['keywords'].split(",")
+
+    body = dict(
+        snippet=dict(
+            title=options['title'],
+            description=options['description'],
+            tags=tags,
+            categoryId=options['category']
+        ),
+        status=dict(
+            privacyStatus=options['privacyStatus']
+        )
+    )
+
+    # Call the API's videos.insert method to create and upload the video.
+    insert_request = youtube.videos().insert(
+    part=",".join(body.keys()),
+    body=body,
+    # The chunksize parameter specifies the size of each chunk of data, in
+    # bytes, that will be uploaded at a time. Set a higher value for
+    # reliable connections as fewer chunks lead to faster uploads. Set a lower
+    # value for better recovery on less reliable connections.
+    #
+    # Setting "chunksize" equal to -1 in the code below means that the entire
+    # file will be uploaded in a single HTTP request. (If the upload fails,
+    # it will still be retried where it left off.) This is usually a best
+    # practice, but if you're using Python older than 2.6 or if you're
+    # running on App Engine, you should set the chunksize to something like
+    # 1024 * 1024 (1 megabyte).
+    media_body=MediaFileUpload(options["file"], chunksize=-1, resumable=True)
+    )
+
+    resumable_upload(insert_request)
+
+# This method implements an exponential backoff strategy to resume a
+# failed upload.
+def resumable_upload(insert_request):
+  response = None
+  error = None
+  retry = 0
+  while response is None:
+    try:
+      print("Uploading file...")
+      status, response = insert_request.next_chunk()
+      if response is not None:
+        if 'id' in response:
+          print("Video id '%s' was successfully uploaded." % response['id'])
+        else:
+          exit("The upload failed with an unexpected response: %s" % response)
+    except HttpError as e:
+      if e.resp.status in RETRIABLE_STATUS_CODES:
+        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
+                                                             e.content)
+      else:
+        raise
+    # except RETRIABLE_EXCEPTIONS as e:
+    #   error = "A retriable error occurred: %s" % e
+
+    if error is not None:
+      print(error)
+      retry += 1
+      if retry > MAX_RETRIES:
+        exit("No longer attempting to retry.")
+
+      max_sleep = 2 ** retry
+      sleep_seconds = random.random() * max_sleep
+      print("Sleeping %f seconds and then retrying..." % sleep_seconds)
+      time.sleep(sleep_seconds)
+
+# def eleven_labs_text_to_speech(text, output_file):
+#     voice_ids = {
+#         "ndntWUKwYjgJGYkvF6at",
+#         "SVLJSgUbrKWfY8HvF2Xd",
+#         "sjdiTCylizqR74A3ssv4",
+#     }
+#     # randomly pick one of the voices
+#     voice_id = random.choice(list(voice_ids))
+#     url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+    
+#     headers = {
+#         "Accept": "audio/mpeg",
+#         "Content-Type": "application/json",
+#         "xi-api-key": ELEVENLABS_KEY
+#     }
+
+#     data = {
+#         "text": text,
+#         "model_id": "eleven_monolingual_v1",
+#         "voice_settings": {
+#             "stability": 0.5,
+#             "similarity_boost": 0.5,
+#             "speed": 0.3,
+#         }
+#     }
+
+#     response = requests.post(url, json=data, headers=headers)
+#     if response.status_code == 200:
+#         with open(output_file, 'wb') as f:
+#             for chunk in response.iter_content(chunk_size=1024):
+#                 f.write(chunk)
+#         print(f"Audio content written to {output_file}")
+#     else:
+#         print(f"Failed to synthesize speech: {response.content}")
+
+def combine_audio_files(audio_files, output_file):
+    combined = AudioSegment.empty()
+    for file in audio_files:
+        audio = AudioSegment.from_mp3(file)
+        combined += audio
+    combined.export(output_file, format="mp3")
+    return output_file
+
+api_key = 'VhLwkCKi3iu5Pf37LXfz-Lp7hTW69EV8uw_hkLAPkiA'  # Replace with your Unsplash API key
+background_image = fetch_random_nature_image(api_key)
+
+if background_image:
+    fetch_reddit_data('Glitch_in_the_Matrix')
+    reddit_data = read_json('top_post.json')
+    title = reddit_data.get('title')
+    selftext = reddit_data.get('selftext')
+
+    # Split title into sentences
+    sentences = nltk.sent_tokenize(selftext)
+    
+    # Generate audio for each sentence and get durations
+    audio_files, audio_durations = tts_per_sentence(sentences, 'audio')
+
+    # Create and save the video
+    create_video_from_title(title, sentences, background_image, "reddit_post_video_cv2.mp4", audio_durations)
+
+    # Combine all audio files into one (if needed)
+    combined_audio_file = combine_audio_files(audio_files, 'combined_voiceover.mp3')  # Implement this function
+
+    filename = "video_" + str(uuid.uuid4())
+
+    # Combine the final video and audio
+    combine_audio_video('reddit_post_video_cv2.mp4', combined_audio_file, filename + '.mp4')
+
+# if background_image:
+#     # Example usage
+#     fetch_reddit_data('Glitch_in_the_Matrix')
+
+#     # Read data from JSON
+#     reddit_data = read_json('top_post.json')  # Change filename if needed
+#     title = reddit_data.get('title')
+
+#     filename = "video_" + str(uuid.uuid4())
+
+#     # Convert text to speech
+#     # voiceover_file = text_to_speech(title, 'voiceover.mp3')
+#     voiceover_file = eleven_labs_text_to_speech(title, 'voiceover.mp3')
+
+#     # Get audio duration
+#     audio_duration = get_audio_duration('voiceover.mp3')
+
+#     # Create and save the video
+#     create_video_from_title(title, background_image, "reddit_post_video_cv2.mp4", audio_duration)
+
+#     # Combine audio and video
+#     combine_audio_video('reddit_post_video_cv2.mp4', 'voiceover.mp3', filename + '.mp4')
+
+#     options = {
+#         'file': 'output/'+ filename + '.mp4',
+#         'title': "Amazing Facts Revealed: Unveiling the World's Hidden Wonders #shorts",
+#         'description':  "Welcome to our latest YouTube video, 'Amazing Facts Revealed: Unveiling the World's Hidden Wonders'! In this enthralling episode, we dive deep into the most astonishing and lesser-known facts about our world. From the mysteries of the deep sea to the enigmas of outer space, we cover it all. Get ready to be amazed by incredible scientific discoveries, historical secrets, and mind-blowing natural phenomena. Each fact is meticulously researched and presented with stunning visuals and engaging narration. Don't forget to like, share, and subscribe for more fascinating content. Stay curious and let's explore the wonders of our world together #shorts",
+#         'category': "22",
+#         'keywords': "facts, shorts, funny",
+#         'privacyStatus': "private"
+#     }
+
+    # try:
+        # youtube = get_authenticated_service()
+        # initialize_upload(youtube, options)
+    #     upload_video_to_drive('output/'+ filename + '.mp4','1t2lcYNLgz6FTeabzccY_06rvcnTGdQiR')
+    # except HttpError as e:
+    #     print("An HTTP error %d occurred:\n%s" % (e.resp.status, e.content))

requirements.txt

@@ -0,0 +1,16 @@
+requests
+praw
+opencv-python
+numpy
+gtts
+pydub
+google-api-python-client
+google-auth
+google-auth-httplib2
+google-auth-oauthlib
+oauth2client
+nltk
+gradio
+soundfile
+transformers
+datasets[audio]

test.py

@@ -0,0 +1,180 @@
+#!/usr/bin/python
+
+import httplib2
+import os
+import random
+import sys
+import time
+
+from apiclient.discovery import build
+from apiclient.errors import HttpError
+from apiclient.http import MediaFileUpload
+from oauth2client.client import flow_from_clientsecrets
+from oauth2client.file import Storage
+from oauth2client.tools import argparser, run_flow
+
+
+# Explicitly tell the underlying HTTP transport library not to retry, since
+# we are handling retry logic ourselves.
+httplib2.RETRIES = 1
+
+# Maximum number of times to retry before giving up.
+MAX_RETRIES = 10
+
+# Always retry when these exceptions are raised.
+# RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib.NotConnected,
+#   httplib.IncompleteRead, httplib.ImproperConnectionState,
+#   httplib.CannotSendRequest, httplib.CannotSendHeader,
+#   httplib.ResponseNotReady, httplib.BadStatusLine)
+
+# Always retry when an apiclient.errors.HttpError with one of these status
+# codes is raised.
+RETRIABLE_STATUS_CODES = [500, 502, 503, 504]
+
+# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
+# the OAuth 2.0 information for this application, including its client_id and
+# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
+# the Google API Console at
+# https://console.cloud.google.com/.
+# Please ensure that you have enabled the YouTube Data API for your project.
+# For more information about using OAuth2 to access the YouTube Data API, see:
+#   https://developers.google.com/youtube/v3/guides/authentication
+# For more information about the client_secrets.json file format, see:
+#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+CLIENT_SECRETS_FILE = "client_secrets.json"
+
+# This OAuth 2.0 access scope allows an application to upload files to the
+# authenticated user's YouTube channel, but doesn't allow other types of access.
+YOUTUBE_UPLOAD_SCOPE = "https://www.googleapis.com/auth/youtube.upload"
+YOUTUBE_API_SERVICE_NAME = "youtube"
+YOUTUBE_API_VERSION = "v3"
+
+# This variable defines a message to display if the CLIENT_SECRETS_FILE is
+# missing.
+MISSING_CLIENT_SECRETS_MESSAGE = """
+WARNING: Please configure OAuth 2.0
+
+To make this sample run you will need to populate the client_secrets.json file
+found at:
+
+   %s
+
+with information from the API Console
+https://console.cloud.google.com/
+
+For more information about the client_secrets.json file format, please visit:
+https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+""" % os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                   CLIENT_SECRETS_FILE))
+
+VALID_PRIVACY_STATUSES = ("public", "private", "unlisted")
+
+
+def get_authenticated_service(args):
+  flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,
+    scope=YOUTUBE_UPLOAD_SCOPE,
+    message=MISSING_CLIENT_SECRETS_MESSAGE)
+
+  storage = Storage("%s-oauth2.json" % sys.argv[0])
+  credentials = storage.get()
+
+  if credentials is None or credentials.invalid:
+    credentials = run_flow(flow, storage, args)
+
+  return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
+    http=credentials.authorize(httplib2.Http()))
+
+def initialize_upload(youtube, options):
+  tags = None
+  if options.keywords:
+    tags = options.keywords.split(",")
+
+  body=dict(
+    snippet=dict(
+      title=options.title,
+      description=options.description,
+      tags=tags,
+      categoryId=options.category
+    ),
+    status=dict(
+      privacyStatus=options.privacyStatus
+    )
+  )
+
+  # Call the API's videos.insert method to create and upload the video.
+  insert_request = youtube.videos().insert(
+    part=",".join(body.keys()),
+    body=body,
+    # The chunksize parameter specifies the size of each chunk of data, in
+    # bytes, that will be uploaded at a time. Set a higher value for
+    # reliable connections as fewer chunks lead to faster uploads. Set a lower
+    # value for better recovery on less reliable connections.
+    #
+    # Setting "chunksize" equal to -1 in the code below means that the entire
+    # file will be uploaded in a single HTTP request. (If the upload fails,
+    # it will still be retried where it left off.) This is usually a best
+    # practice, but if you're using Python older than 2.6 or if you're
+    # running on App Engine, you should set the chunksize to something like
+    # 1024 * 1024 (1 megabyte).
+    media_body=MediaFileUpload(options.file, chunksize=-1, resumable=True)
+  )
+
+  resumable_upload(insert_request)
+
+# This method implements an exponential backoff strategy to resume a
+# failed upload.
+def resumable_upload(insert_request):
+  response = None
+  error = None
+  retry = 0
+  while response is None:
+    try:
+      print("Uploading file...")
+      status, response = insert_request.next_chunk()
+      if response is not None:
+        if 'id' in response:
+          print("Video id '%s' was successfully uploaded." % response['id'])
+        else:
+          exit("The upload failed with an unexpected response: %s" % response)
+    except HttpError as e:
+      if e.resp.status in RETRIABLE_STATUS_CODES:
+        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
+                                                             e.content)
+      else:
+        raise
+    # except RETRIABLE_EXCEPTIONS as e:
+    #   error = "A retriable error occurred: %s" % e
+
+    if error is not None:
+      print(error)
+      retry += 1
+      if retry > MAX_RETRIES:
+        exit("No longer attempting to retry.")
+
+      max_sleep = 2 ** retry
+      sleep_seconds = random.random() * max_sleep
+      print("Sleeping %f seconds and then retrying..." % sleep_seconds)
+      time.sleep(sleep_seconds)
+
+if __name__ == '__main__':
+  argparser.add_argument("--file", required=True, help="Video file to upload")
+  argparser.add_argument("--title", help="Video title", default="Test Title")
+  argparser.add_argument("--description", help="Video description",
+    default="Test Description")
+  argparser.add_argument("--category", default="22",
+    help="Numeric video category. " +
+      "See https://developers.google.com/youtube/v3/docs/videoCategories/list")
+  argparser.add_argument("--keywords", help="Video keywords, comma separated",
+    default="")
+  argparser.add_argument("--privacyStatus", choices=VALID_PRIVACY_STATUSES,
+    default=VALID_PRIVACY_STATUSES[0], help="Video privacy status.")
+  args = argparser.parse_args()
+
+  if not os.path.exists(args.file):
+    exit("Please specify a valid file using the --file= parameter.")
+
+  youtube = get_authenticated_service(args)
+  try:
+    initialize_upload(youtube, args)
+  except HttpError as e:
+    print("An HTTP error %d occurred:\n%s" % (e.resp.status, e.content))

tik.py

@@ -0,0 +1,38 @@
+from flask import Flask, request, redirect
+import requests
+import random
+
+app = Flask(__name__)
+
+CLIENT_ID = 'awfh19twbfyt0de0'
+CLIENT_SECRET = 'awfh19twbfyt0de0'
+REDIRECT_URI = 'https://127.0.0.1:5000/callback/'  # This must match the redirect URI registered in TikTok Developer Portal
+
+@app.route('/')
+def home():
+    csrfState = format(random.randint(0, 36**16), 'x')
+
+    # Redirect the user to TikTok's authorization page
+    tiktok_auth_url = f"https://open-api.tiktok.com/platform/oauth/connect/?client_key={CLIENT_ID}&scope=user.info.basic,video.list&response_type=code&redirect_uri={REDIRECT_URI}&state={csrfState}"
+    return redirect(tiktok_auth_url)
+
+@app.route('/callback')
+def callback():
+    # Get the code from the callback URL
+    code = request.args.get('code')
+
+    # Exchange the code for an access token
+    token_url = "https://open-api.tiktok.com/oauth/access_token/"
+    payload = {
+        'client_key': CLIENT_ID,
+        'client_secret': CLIENT_SECRET,
+        'code': code,
+        'grant_type': 'authorization_code',
+    }
+    response = requests.post(token_url, data=payload)
+    access_token = response.json().get('data', {}).get('access_token')
+
+    return f"Access Token: {access_token}"
+
+if __name__ == '__main__':
+    app.run(debug=True)

top_post.json

@@ -0,0 +1,4 @@
+{
+    "title": "It wasn\u2019t my grandfather\u2019s body in the casket",
+    "selftext": "This happened last year. My grandfather\u2019s health had been declining from dementia for several months until one day he just dropped dead on the floor at home. Despite how sudden it was, he went peacefully.\n\nI hadn\u2019t seen him since Christmas almost a full year prior, and even though he didn\u2019t look so great, he was completely recognizable as him. Then the day of the funeral came and I hesitated to get close to his body. It was my first time as an adult having a family member die, and it just felt\u2026 more bleak than my other grandparents who died back when I was a kid or teen.\n\nEventually, I couldn\u2019t avoid it anymore, and my mom led me to the casket. When I saw his face, it wasn\u2019t his. It was mine.\n\nHis hair, his nose, his bone structure were all gone, replaced with my own features. I was staring at my own dead body lying in the casket, and no matter how many times I rubbed my eyes or looked away, it never changed.\n\nI don\u2019t look like my grandfather. For starters, I\u2019m a woman. My face is thinner, my jaw has a different shape, and my nose is pretty unique. Granted, I have short hair\u2014a bit like his\u2014but not the exact same. But it was undeniably me in the casket. Not someone who looked like me. It was me.\n\nI left the casket and began talking with family members. Every so often, I\u2019d go back to see if something had changed, though it was always the same. No one else mentioned it, and I was too scared to say anything myself. So I thought I must be the only one seeing myself in the casket\n\nIn all likelihood, it must have been a hallucination of some kind. Maybe it was some sort of stress response my brain created in the moment, but it\u2019s odd that nothing else was affected by the hallucination. Not a single thing seemed out of the ordinary aside from my body being in the casket.\n\nI don\u2019t know what it means, but it freaked me out."
+}

tts.py

@@ -0,0 +1,15 @@
+from transformers import pipeline
+from datasets import load_dataset
+import torch
+
+print(torch.cuda.is_available())  # Should return True if a GPU is available
+
+synthesiser = pipeline("text-to-speech", "microsoft/speecht5_tts")
+
+embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
+speaker_embedding = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
+# You can replace this embedding with your own as well.
+
+# speech = synthesiser("Hello, my dog is cooler than you!", forward_params={"speaker_embeddings": speaker_embedding})
+
+# sf.write("speech.wav", speech["audio"], samplerate=speech["sampling_rate"])