xd

app.py

@@ -1,35 +1,293 @@
+import pixabay.core
+import glob
+from moviepy.editor import VideoFileClip, ImageClip, concatenate_videoclips, AudioFileClip,CompositeVideoClip, TextClip
+import requests
+import random
+import moviepy.editor as mp
 import gradio as gr
-from selenium import webdriver
-from selenium.common.exceptions import WebDriverException
-from PIL import Image
-from io import BytesIO
+import time
+import re
+import os
 
-def take_screenshot(url):
-    options = webdriver.ChromeOptions()
-    options.add_argument('--headless')
-    options.add_argument('--no-sandbox')
-    options.add_argument('--disable-dev-shm-usage')
+from googletrans import Translator
 
+import ffmpeg
+
+import json
+import openai
+
+
+openai.api_key = os.environ["API_KEY"]  # 首先要有apikey
+
+#openai.api_key = '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'
+
+messages = [{"role": "system", "content": "eres una mano derecha"}]
+
+
+def chatgpt(content, temperature=0.8):
+    global messages
+    print(f'ask:{content}')
+    messages.append({"role": "user", "content": content})
+    time.sleep(1)
     try:
-        wd = webdriver.Chrome(options=options)
-        wd.set_window_size(1080, 720)  # Adjust the window size here
-        wd.get(url)
-        wd.implicitly_wait(10)
-        screenshot = wd.get_screenshot_as_png()
-    except WebDriverException as e:
-        return Image.new('RGB', (1, 1))
-    finally:
-        if wd:
-            wd.quit()
-
-    return Image.open(BytesIO(screenshot))
-
-iface = gr.Interface(
-    fn=take_screenshot,
-    inputs=gr.inputs.Textbox(label="Website URL", default="https://kargaranamir.github.io"),
-    outputs=gr.Image(type="pil", height=360, width=540),  # Adjust the image size here
-    title="Website Screenshot",
-    description="Take a screenshot of a website.",
-)
-
-iface.launch()
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo-0301",  # 或者 gpt-3.5-turbo-0301
+            messages=messages,
+            temperature=temperature,
+            max_tokens=1000,
+            top_p=1,
+            frequency_penalty=0,
+            presence_penalty=0,
+        )
+    except Exception as e:
+        messages = [{"role": "system", "content": "eres una mano derecha"}]
+        return 'Este mensaje interactivo ha alcanzado el límite superior, el token se ha borrado, vuelva a ingresar'
+    messages.append(json.loads(str(response.choices[0].message)))
+    print(f'answer:{response.choices[0].message.content}')
+    resulado = response.choices[0].message.content
+    resulado = resulado.replace('.','')
+    return resulado
+
+
+
+pixabayapi = ''
+def generaraudio2(texto):
+    nombre = s=re.sub('[^A-Za-z0-9]+', '',texto)
+    nombre = nombre.strip()
+    archivo = 'es_'+nombre+'.wav'
+    print(archivo)
+    existe = glob.glob(archivo)
+    texto = texto.lower()
+    texto = texto.replace('html5','hache te eme ele cinco')
+    texto = texto.replace('html','hache te eme ele')
+    texto = texto.replace('pdf','pe de eefe')
+    texto = texto.replace('bit.ly','bit punto li!, eslach,')
+    texto = texto.replace('.',',')
+    texto = texto.replace('1','uno')
+    texto = texto.replace('2','dos')
+    texto = texto.replace('3','tres')
+    texto = texto.replace('4','cuatro')
+    texto = texto.replace('5','cinco')
+    texto = texto.replace('6','seis')
+    texto = texto.replace('7','siete')
+    texto = texto.replace('8','ocho')
+    texto = texto.replace('9','nueve')
+    if not existe:
+        response = requests.post("https://iricardoxd-texto-a-voz-aws.hf.space/api/predict", json={
+        "data": [
+            texto
+        ]},headers={'Content-Type':'application/json','Authorization': 'Bearer {}'.format('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')}).json()
+        data = response["data"]
+        print(response['data'][0]['name'])
+        time.sleep(5)
+        response = requests.get("https://iricardoxd-texto-a-voz-aws.hf.space/file="+response['data'][0]['name'],headers={'Content-Type':'application/json','Authorization': 'Bearer {}'.format('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')})
+        if response.status_code == 200:
+            open(archivo, 'wb').write(response.content)
+            print('downloaded')
+        else:
+            print(response.status_code)
+    return archivo
+import requests
+import shutil
+def buscar(palabra,category):
+    xd = palabra.split()
+    xdfile = '_'.join(xd)
+    xdfile = xdfile.replace('/','').replace('"','').replace('.','').replace('!','').replace('@','').replace('\\','').replace('\n','').replace('\rn','').replace(':','').replace(',','')
+    archivo = category+'_'+xdfile+".mp4"
+    #existe = glob.glob(archivo)
+    if True:#not existe:
+        # Establece tu clave de API de Pexels
+        PEXELS_API_KEY = '563492ad6f917000010000011b2f873942744900a033f732a56ae4b7'
+        translator = Translator()
+        search_term = translator.translate(palabra, dest='en').text#blob.translate(to='en')
+        print(search_term)
+        # Crea el URL de la API
+        api_url = f'https://api.pexels.com/videos/search?query={search_term}&orientation=portrait&per_page=3&locale=en-US'
+        print(api_url)
+        # Establece los encabezados de la solicitud
+        headers = {'Authorization': PEXELS_API_KEY}
+        
+        # Realiza la solicitud a la API
+        response = requests.get(api_url, headers=headers)
+        
+        # Verifica si la solicitud fue exitosa
+        if response.status_code == 200:
+            # Obtiene los resultados de la búsqueda
+            results = response.json()['videos']
+            #print(results)
+            # Itera sobre los resultados
+            if len(results)>0:
+                ancho = 1
+                ancho = ancho - 1
+                numero = random.randint(0,ancho)
+                print('el numero es ',numero)
+                # Obtiene el URL del video
+                for videox in results[numero]['video_files']:
+                    if videox['height']==1920:
+                        video_url = videox['link']
+                    else:
+                        if videox['quality']=='hd':
+                            video_url = videox['link']
+                        else:    
+                            video_url = results[numero]['video_files'][0]['link']
+                print('el video es',video_url)
+        
+                # Descarga el video
+                with requests.get(video_url, stream=True) as r:
+                    with open(archivo, 'wb') as f:
+                        shutil.copyfileobj(r.raw, f)
+        
+                print(f'Descargado video {numero} de {len(results)}')
+            else:
+                api_url2 = f'https://api.pexels.com/v1/search?query={search_term}&per_page=1&orientation=portrait&locale=en-US'
+                print(api_url2)
+                response2 = requests.get(api_url2, headers=headers)
+                if response2.status_code == 200:
+                    # Obtiene los resultados de la búsqueda
+                    results2 = response2.json()['photos']
+                # Itera sobre los resultados
+                    if len(results2)>0:
+                        ancho = 1
+                        ancho = ancho - 1
+                        numero = random.randint(0,ancho)
+                        print('el numero es ',numero)
+                        # Obtiene el URL del video
+                        video_url = results2[numero]['src']['portrait']
+                        imagen = results2[numero]['src']['original']
+                        filex = imagen.split('/')
+                        print(' imagen es',video_url)
+                        x=len(filex)-1
+                        archivo=filex[x]
+                        print(' imagen es x ',archivo)
+                        # Descarga el video
+                        with requests.get(video_url, stream=True) as r:
+                            with open(archivo, 'wb') as f:
+                                shutil.copyfileobj(r.raw, f)
+                
+                        print(f'Descargado imagen {numero} de {len(results)}')
+                    else:
+                        archivo='doctor.mp4'
+        else:
+            print('Error al realizar la solicitud a la API')
+    return archivo
+def buscarsustantivo(frase):
+    if frase !='':
+        prompt ='Respond only with one word of videos availables in pixels.com that best expresses the English phrase: '+frase
+        return chatgpt(prompt)
+
+def combinar(frase, api_pixabay):
+    global pixabayapi
+    pixabayapi = '38938115-4ffafdfccf94d14e4d35899f5'
+    category="travel"
+    clips = []
+    palabras = frase.split(' ')
+    palabras_frases = frase.split('.')
+    frases = []
+    i = 0
+    linea = ''
+    for palabra in palabras:
+        i = i + 1
+        linea = linea + ' ' + palabra
+        escena_palabras = random.randint(1, 5)
+        if i>escena_palabras or '.' in linea or '?' in linea or '!' in linea:
+            i=0
+            frases.append(linea)
+            linea = ''
+    if linea !='':
+        frases.append(linea)
+    duracionTotal = 0
+    for lineaf in frases:
+        tema = buscarsustantivo(lineaf)
+        palabras_de_tema = tema.split(' ')
+        if len(palabras_de_tema)>1:
+            tema = palabras_de_tema[0]
+        #for tema in temas:
+        if len(tema)>0:
+            palabraclave = tema
+        else:
+            palabraclave = frases[0]
+        print(palabraclave)
+        resultado = buscar(palabraclave,category)
+        if(resultado=='lv_0_20230901171552.mp4'):
+            tema = buscarsustantivo(lineaf)
+            palabras_de_tema = tema.split(' ')
+            if len(palabras_de_tema)>1:
+                tema = palabras_de_tema[0]
+            #for tema in temas:
+            if len(tema)>0:
+                palabraclave = tema
+            else:
+                palabraclave = frases[0]
+            print(palabraclave)
+            resultado = buscar(palabraclave,category)
+        if resultado!=None:
+            velocidadhabla = 15#catacteres por segundos 18 teresa, 22 huggie
+            print(len(lineaf))
+            duracion = len(lineaf)/velocidadhabla
+            print(resultado)
+            try:
+                audiofile = generaraudio2(lineaf)
+                clip1 = VideoFileClip(generate_subtitled_video(resultado,lineaf))
+                audio = AudioFileClip(audiofile)
+                #duracion = audio.duration
+                duracionTotal = duracionTotal + duracion
+                subclip = clip1.subclip(0, duracion)
+                resized_clip = subclip.resize((1080, 1920))
+                video = resized_clip.resize(height=1920)
+                final_clip = video#final_clip = video.crop(x1=1166.6,y1=0,x2=2246.6,y2=1920)
+                final_clip.audio = audio
+                clips.append(final_clip)
+            except Exception as e:
+                print(f'Ocurrió un error: {e}')
+                clip = ImageClip(resultado)
+                # Establece la duración del clip en segundos
+                clip = clip.set_duration(5)
+                # Guarda el clip como un archivo de video
+                clip.write_videofile('videoxd.mp4', fps=24)
+                audiofile = generaraudio2(lineaf)
+                clip1 = VideoFileClip(generate_subtitled_video('videoxd.mp4',lineaf))#generate_subtitled_video('videoxd.mp4',audiofile,lineaf))
+                audio = AudioFileClip(audiofile)
+                #duracion = audio.duration
+                duracionTotal = duracionTotal + duracion
+                subclip = clip1.subclip(0, duracion)
+                resized_clip = subclip.resize((1080, 1920))
+                video = resized_clip.resize(height=1920)
+                final_clip = video#final_clip = video.crop(x1=1166.6,y1=0,x2=2246.6,y2=1920)
+                #final_clip.audio = audio
+                clips.append(final_clip)
+    filename=palabras_frases[0]+'.mp4'            
+    if len(clips)>0:
+        audiofilefinal = generaraudio2(frase)
+        final_clip = concatenate_videoclips(clips)
+        final_clip.audio = AudioFileClip(audiofilefinal)
+        final_clip.write_videofile(filename)
+    print('listo video')
+    final = filename
+    subir(filename,palabras_frases[0])
+    html= '<a href="file/'+final+'" download>Descargar video</a><a href="file/final.mp4" download>Descargar video</a>'
+    return (final,html)
+def generate_subtitled_video(video, transcript):
+    input = ffmpeg.input(video)
+    output = ffmpeg.output(input, 'srt'+video, vf="drawtext=text='"+transcript+"':fontcolor=white:fontsize=24:box=1:boxcolor=black@0.5:boxborderw=5:x=(w-text_w)/2:y=((h-text_h-line_h)/9)*10")
+    output.run(quiet=True, overwrite_output=True)
+    video_with_subs = 'srt'+video
+    print(video_with_subs)
+    return video_with_subs     
+def subir(video,descripcion):
+    from upload import upload_videos
+    from auth import AuthBackend
+
+    videos = [
+        {
+            'video': video,
+            'description': descripcion
+        }
+    ]
+
+    auth = AuthBackend(cookies='cookies.txt')
+    failed_videos = upload_videos(videos=videos, auth=auth)
+
+    for video in failed_videos: # each input video object which failed
+        print(f'{video["video"]} with description "{video["description"]}" failed')    
+demo = gr.Interface(fn=combinar, inputs=["text","text"], outputs=["video","html"])
+demo.launch()

auth.py

@@ -0,0 +1,227 @@
+"""Handles authentication for TikTokUploader"""
+from http import cookiejar
+from time import time, sleep
+
+from selenium.webdriver.common.by import By
+
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+from tiktok_uploader import config, logger
+from tiktok_uploader.browsers import get_browser
+from tiktok_uploader.utils import green
+
+class AuthBackend:
+    """
+    Handles authentication for TikTokUploader
+    """
+    username: str
+    password: str
+    cookies: list
+
+    def __init__(self, username: str = '', password: str = '',
+                 cookies_list: list = None, cookies=None, cookies_str=None, sessionid: str = None):
+        """
+        Creates the authenticaiton backend
+
+        Keyword arguments:
+        - username -> the accounts's username or email
+        - password -> the account's password
+
+        - cookies -> a list of cookie dictionaries of cookies which is Selenium-compatable
+        """
+        if (username and not password) or (password and not username):
+            raise InsufficientAuth()
+
+        self.cookies = self.get_cookies(path=cookies) if cookies else []
+        self.cookies += self.get_cookies(cookies_str=cookies_str) if cookies_str else []
+        self.cookies += cookies_list if cookies_list else []
+        self.cookies += [{'name': 'sessionid', 'value': sessionid}] if sessionid else []
+
+        if not (self.cookies or (username and password)):
+            raise InsufficientAuth()
+
+        self.username = username
+        self.password = password
+
+        if cookies:
+            logger.debug(green("Authenticating browser with cookies"))
+        elif username and password:
+            logger.debug(green("Authenticating browser with username and password"))
+        elif sessionid:
+            logger.debug(green("Authenticating browser with sessionid"))
+        elif cookies_list:
+            logger.debug(green("Authenticating browser with cookies_list"))
+
+
+    def authenticate_agent(self, driver):
+        """
+        Authenticates the agent using the browser backend
+        """
+        # tries to use cookies
+        if not self.cookies and self.username and self.password:
+            self.cookies = login(driver, username=self.username, password=self.password)
+
+        logger.debug(green("Authenticating browser with cookies"))
+
+        driver.get(config['paths']['main'])
+
+        WebDriverWait(driver, config['explicit_wait']).until(EC.title_contains("TikTok"))
+
+        for cookie in self.cookies:
+            try:
+                driver.add_cookie(cookie)
+            except Exception as _:
+                logger.error('Failed to add cookie %s', cookie)
+
+        return driver
+
+
+    def get_cookies(self, path: str = None, cookies_str: str = None) -> dict:
+        """
+        Gets cookies from the passed file using the netscape standard
+        """
+        if path:
+            with open(path, "r", encoding="utf-8") as file:
+                lines = file.read().split("\n")
+        else:
+            lines = cookies_str.split("\n")
+
+        return_cookies = []
+        for line in lines:
+            split = line.split('\t')
+            if len(split) < 6:
+                continue
+
+            split = [x.strip() for x in split]
+
+            try:
+                split[4] = int(split[4])
+            except ValueError:
+                split[4] = None
+
+            return_cookies.append({
+                'name': split[5],
+                'value': split[6],
+                'domain': split[0],
+                'path': split[2],
+            })
+
+            if split[4]:
+                return_cookies[-1]['expiry'] = split[4]
+        return return_cookies
+
+
+def login_accounts(driver=None, accounts=[(None, None)], *args, **kwargs) -> list:
+    """
+    Authenticates the accounts using the browser backend and saves the required credentials
+
+    Keyword arguments:
+    - driver -> the webdriver to use
+    - accounts -> a list of tuples of the form (username, password)
+    """
+    driver = driver or get_browser(headless=True, *args, **kwargs)
+
+    cookies = {}
+    for account in accounts:
+        username, password = get_username_and_password(account)
+
+        cookies[username] = login(driver, username, password)
+
+    return cookies
+
+
+def login(driver, username: str, password: str):
+    """
+    Logs in the user using the email and password
+    """
+    assert username and password, "Username and password are required"
+
+    # checks if the browser is on TikTok
+    if not config['paths']['main'] in driver.current_url:
+        driver.get(config['paths']['main'])
+
+    # checks if the user is already logged in
+    if driver.get_cookie(config['selectors']['login']['cookie_of_interest']):
+        # clears the existing cookies
+        driver.delete_all_cookies()
+
+    # goes to the login site
+    driver.get(config['paths']['login'])
+
+    # selects and fills the login and the password
+    username_field = WebDriverWait(driver, config['explicit_wait']).until(
+        EC.presence_of_element_located((By.XPATH, config['selectors']['login']['username_field']))
+        )
+    username_field.clear()
+    username_field.send_keys(username)
+
+    password_field = driver.find_element(By.XPATH, config['selectors']['login']['password_field'])
+    password_field.clear()
+    password_field.send_keys(password)
+
+    # submits the form
+    submit = driver.find_element(By.XPATH, config['selectors']['login']['login_button'])
+    submit.click()
+
+    print(f'Complete the captcha for {username}')
+
+    # Wait until the session id cookie is set
+    start_time = time()
+    while not driver.get_cookie(config['selectors']['login']['cookie_of_interest']):
+        sleep(0.5)
+        if time() - start_time > config['explicit_wait']:
+            raise InsufficientAuth() # TODO: Make this something more real
+
+    # wait until the url changes
+    WebDriverWait(driver, config['explicit_wait']).until(EC.url_changes(config['paths']['login']))
+
+    return driver.get_cookies()
+
+
+def get_username_and_password(login_info: tuple or dict):
+    """
+    Parses the input into a username and password
+    """
+    if not isinstance(login_info, dict):
+        return login_info[0], login_info[1]
+
+    # checks if they used email or username
+    if 'email' in login_info:
+        return login_info['email'], login_info['password']
+    elif 'username' in login_info:
+        return login_info['username'], login_info['password']
+
+    raise InsufficientAuth()
+
+
+def save_cookies(path, cookies: list):
+    """
+    Saves the cookies to a netscape file
+    """
+    # saves the cookies to a file
+    cookie_jar = cookiejar.MozillaCookieJar(path)
+    cookie_jar.load()
+
+    for cookie in cookies:
+        cookie_jar.set_cookie(cookie)
+
+    cookie_jar.save()
+
+
+class InsufficientAuth(Exception):
+    """
+    Insufficient authentication:
+
+    > TikTok uses cookies to keep track of the user's authentication or session.
+
+    Either:
+        - Use a cookies file passed as the `cookies` argument
+            - easily obtained using https://github.com/kairi003/Get-cookies.txt-LOCALLY
+        - Use a cookies list passed as the `cookies_list` argument
+            - can be obtained from your browser's developer tools under storage -> cookies
+            - only the `sessionid` cookie is required
+    """
+
+    def __init__(self, message=None):
+        super().__init__(message or self.__doc__)

config.toml

@@ -0,0 +1,75 @@
+# TikTok Uploader Default Configuation File
+
+headless = true
+quit_on_end = true
+
+# Messing around with inputs
+valid_path_names = ["path", "filename", "video", "video_path"]
+valid_descriptions = ["description", "desc", "caption"]
+
+# Selenium Webdriver Waits
+implicit_wait = 5  # seconds
+explicit_wait = 60 # seconds
+
+supported_file_types = ["mp4", "mov", "avi", "wmv", "flv", "webm", "mkv", "m4v", "3gp", "3g2", "gif"]
+
+max_description_length = 150 # characters
+
+[paths]
+main = "https://www.tiktok.com/"
+login = "https://www.tiktok.com/login/phone-or-email/email"
+upload = "https://www.tiktok.com/creator-center/upload?from=upload"
+
+[disguising]
+user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+
+[selectors] # Selenium XPATH selectors
+
+	[selectors.login]
+	username_field = "//input[@name=\"username\"]"
+	password_field = "//input[@type=\"password\"]"
+	login_button = "//button[@type=\"submit\"]"
+	
+	alert_user_if_failed = true # sends an alert and waits instead of failing
+	
+	cookie_of_interest = "sessionid" # cookie to check if login was successful
+	
+	[selectors.upload]
+	iframe = "//iframe"
+	
+	upload_video = "//input[@type='file']"
+	upload_in_progress = "//*[.='Cancelar']"
+	upload_confirmation = "//video" 
+	process_confirmation = "//img[@draggable='false']"
+
+	description = "//div[@contenteditable='true']"
+
+	visibility = "//div[@class='tiktok-select-selector']"
+	options = ["Public", "Friends", "Private"]
+
+	hashtags = "//div[@class='mentionSuggestions']//*[contains(text(), '{}')]"
+	mentions = "//div[contains(concat(' ', normalize-space(@class), ' '), 'user-id') and .='{}']/.."
+
+	mention_box = "//input[contains(concat(' ', normalize-space(@class), ' '), 'search-friends')]"
+
+	comment = "//label[.='Comment']/following-sibling::div/input"
+	duet = "//label[.='Duet']/following-sibling::div/input"
+	stitch = "//label[.='Stitch']/following-sibling::div/input"
+
+	post = "//div[contains(@class, 'btn-post')]"
+	post_confirmation = "//div[.='Your videos are being uploaded to TikTok!']"
+
+	[selectors.schedule]
+	switch = "//*[@id='tux-3']"
+
+	date_picker = "//div[contains(@class, 'date-picker-input')]"
+	calendar = "//div[contains(@class, 'calendar-wrapper')]"
+	calendar_month = "//span[contains(@class, 'month-title')]"
+	calendar_valid_days = "//div[@class='jsx-4172176419 days-wrapper']//span[contains(@class, 'day') and contains(@class, 'valid')]"
+	calendar_arrows = "//span[contains(@class, 'arrow')]"  # first last, second next
+
+	time_picker = "//div[contains(@class, 'time-picker-input')]"
+	time_picker_text = "//div[contains(@class, 'time-picker-input')]/*[1]"
+	time_picker_container = "//div[@class='tiktok-timepicker-time-picker-container']"
+	timepicker_hours = "//span[contains(@class, 'tiktok-timepicker-left')]"
+	timepicker_minutes = "//span[contains(@class, 'tiktok-timepicker-right')]"

cookies.txt

@@ -0,0 +1,31 @@
+# Netscape HTTP Cookie File
+# http://curl.haxx.se/rfc/cookie_spec.html
+# This is a generated file!  Do not edit.
+
+.www.tiktok.com	TRUE	/	TRUE	1696204457	tiktok_webapp_theme	light
+.tiktok.com	TRUE	/	TRUE	1700680950	passport_csrf_token	2fcbe4468644121124e160b2bd58f363
+.tiktok.com	TRUE	/	FALSE	1700680950	passport_csrf_token_default	2fcbe4468644121124e160b2bd58f363
+.tiktok.com	TRUE	/	TRUE	1711151649	tt_chain_token	Rt2x5VfQLupBGHX2zAaeKQ==
+.www.tiktok.com	TRUE	/	FALSE	1696204455	__tea_cache_tokens_1988	{%22_type_%22:%22default%22%2C%22user_unique_id%22:%227282105198122092075%22%2C%22timestamp%22:1695497380126}
+.tiktok.com	TRUE	/	TRUE	1700681741	multi_sids	7282105716742734890%3A747d8454c7769596ecaf4ae3d1579662
+.tiktok.com	TRUE	/	TRUE	1700681741	cmpl_token	AgQQAPNSF-RO0rUx0janeB0T_26lK8CI_6nZYMy3Aw
+.tiktok.com	TRUE	/	TRUE	1711049741	sid_guard	747d8454c7769596ecaf4ae3d1579662%7C1695497740%7C15552000%7CThu%2C+21-Mar-2024+19%3A35%3A40+GMT
+.tiktok.com	TRUE	/	TRUE	1711049741	uid_tt	16c13984b11d11e7bcbf81c40c4fc99d4589d115466d2c20f7579350a6ffedd5
+.tiktok.com	TRUE	/	TRUE	1711049741	uid_tt_ss	16c13984b11d11e7bcbf81c40c4fc99d4589d115466d2c20f7579350a6ffedd5
+.tiktok.com	TRUE	/	TRUE	1711049741	sid_tt	747d8454c7769596ecaf4ae3d1579662
+.tiktok.com	TRUE	/	TRUE	1711049741	sessionid	747d8454c7769596ecaf4ae3d1579662
+.tiktok.com	TRUE	/	TRUE	1711049741	sessionid_ss	747d8454c7769596ecaf4ae3d1579662
+.tiktok.com	TRUE	/	TRUE	1711049741	sid_ucp_v1	1.0.0-KDcyZWZmZjFjMWViNTgwMWMzZDQ3NjRhNTU1NzRjMGIxY2QyM2JkMTUKIAiqiKv6kpLPh2UQjPy8qAYYswsgDDCf-byoBjgBQOsHEAQaB3VzZWFzdDUiIDc0N2Q4NDU0Yzc3Njk1OTZlY2FmNGFlM2QxNTc5NjYy
+.tiktok.com	TRUE	/	TRUE	1711049741	ssid_ucp_v1	1.0.0-KDcyZWZmZjFjMWViNTgwMWMzZDQ3NjRhNTU1NzRjMGIxY2QyM2JkMTUKIAiqiKv6kpLPh2UQjPy8qAYYswsgDDCf-byoBjgBQOsHEAQaB3VzZWFzdDUiIDc0N2Q4NDU0Yzc3Njk1OTZlY2FmNGFlM2QxNTc5NjYy
+.tiktok.com	TRUE	/	FALSE	1711049740	store-idc	useast5
+.tiktok.com	TRUE	/	FALSE	1711049740	store-country-code	us
+.tiktok.com	TRUE	/	FALSE	1711049740	store-country-code-src	uid
+.tiktok.com	TRUE	/	FALSE	1711049740	tt-target-idc	useast5
+.tiktok.com	TRUE	/	FALSE	1711049754	tt-target-idc-sign	3G_umYol_pR5-9ql6JlmS_vAG-oxfye8T1PW1DwPhJstsWwuBM2naJyAcfB0zdi3iVioRSpKo9S7EMPiSOtqiUbUo8-iB_LMGkSkCCB8NjPZxq3XvWw4TuTHJrAQE-KKAWVvLMPRpGHhmPYaiaVS3V6rRCKbGyZXvw26F9jfVNOPTrobntczrQMSR7wnwLPfyIKmKLsqZ3FZUS8u8ZakrgZhVK1c9P9wRHo0rdrWJ8p871cqBu9lVYoeVFL-eT8LaYN3EjWJK_S3ySqXuIJTsABbn9RokzBI4kEIx7Rysds1bBidJPPC6N29PkJbwSnaniSy4Q1kRu9oQNl-d80LsqMcRaP6gj19zVkmwoTBQ7bXaIJoo1-nq2WGA7EhlTroDhbxsS_mnV1e12UASiigajxfccDY8k3bU4qej4FQj0_73OEQVpRayxr9jK34w9CgGozzxVRFfyIAtAnTkpwZmTzqxrOhYn5JW3mI4HaK-xtAeI88l34FC6uXMw2Yg0aH
+.tiktok.com	TRUE	/	TRUE	0	tt_csrf_token	YVpr7bGu-pagI4x0nJWqcHju8QT9akkzF-K4
+.www.tiktok.com	TRUE	/	FALSE	0	passport_fe_beating_status	true
+.tiktok.com	TRUE	/	TRUE	1711151664	ttwid	1%7CBffw97Kt4MoFtptEg0otV7ohXh9iyAh9ShYIEX2fUug%7C1695599664%7Cf95f7655258ee6bd0a66af03e4bb410e33f3fc54711a8e9e03f1f55507ae47a8
+.tiktok.com	TRUE	/	FALSE	1711151665	odin_tt	9c735b8191086bf88a56b57173f76d2b543edca8c95410eee89502a1f33861ebe6c9b08c2e01e2eb2e9c21cddc0eb82fadfdd2a9a8b738b16202e183f3ae0003ab015dc977f2a30bc485784adf36040a
+www.tiktok.com	FALSE	/	TRUE	0	csrf_session_id	91570471488ad14ddabf4f3f567cf8b4
+.tiktok.com	TRUE	/	TRUE	1696463793	msToken	ULaJAPtAQlIhCv-aMXKoBMeeLfw0h_LYPD4nyD6nifbdb8c5rb-72ohf2PRIpn3DUwz8aD4HX-RTr6lB946CB2qqV3ulguPmFOJ7yWC9i4nHCA83Z3kaChw71JJr5Yif_iFbbIe-Cegg
+www.tiktok.com	FALSE	/	FALSE	1696204593	msToken	ULaJAPtAQlIhCv-aMXKoBMeeLfw0h_LYPD4nyD6nifbdb8c5rb-72ohf2PRIpn3DUwz8aD4HX-RTr6lB946CB2qqV3ulguPmFOJ7yWC9i4nHCA83Z3kaChw71JJr5Yif_iFbbIe-Cegg

proxy_auth_extension/background.js

@@ -0,0 +1,28 @@
+var config = {
+        mode: "fixed_servers",
+        rules: {
+        singleProxy: {
+            scheme: "http",
+            host: "{{ proxy_host }}",
+            port: parseInt("{{ proxy_port }}")
+        },
+        bypassList: ["localhost"]
+        }
+    };
+
+chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});
+
+function callbackFn(details) {
+    return {
+        authCredentials: {
+            username: "{{ proxy_user }}",
+            password: "{{ proxy_pass }}"
+        }
+    };
+}
+
+chrome.webRequest.onAuthRequired.addListener(
+            callbackFn,
+            {urls: ["<all_urls>"]},
+            ['blocking']
+);

proxy_auth_extension/manifest.json

@@ -0,0 +1,18 @@
+{
+    "version": "1.0.0",
+    "manifest_version": 2,
+    "name": "Chrome Proxy",
+    "permissions": [
+        "proxy",
+        "tabs",
+        "unlimitedStorage",
+        "storage",
+        "<all_urls>",
+        "webRequest",
+        "webRequestBlocking"
+    ],
+    "background": {
+        "scripts": ["background.js"]
+    },
+    "minimum_chrome_version":"22.0.0"
+}

proxy_auth_extension/proxy_auth_extension.py

@@ -0,0 +1,63 @@
+import zipfile
+import os
+import json
+from selenium.webdriver.common.by import By
+
+
+def replace_variables_in_js(js_content: str, variables_dict: dict):
+    for variable, value in variables_dict.items():
+        js_content = js_content.replace('{{ ' + variable + ' }}', value)
+    return js_content
+
+
+def generate_proxy_auth_extension(
+        proxy_host: str, proxy_port: str, proxy_user: str, proxy_pass: str,
+        extension_file: str):
+    """Generate a Chrome extension that modify proxy settings based on desired host, port, username and password.
+
+    If you are using --headless in chromedriver, you must use --headless=new to support extensions in headless mode.
+    """
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    manifest_json_path = os.path.join(current_dir, 'manifest.json')
+    background_js_path = os.path.join(current_dir, 'background.js')
+    with open(manifest_json_path, 'r', encoding='utf-8') as f:
+        manifest_json = f.read()
+    with open(background_js_path, 'r', encoding='utf-8') as f:
+        background_js = f.read()
+
+    variables_dict = {
+        'proxy_host': proxy_host,
+        'proxy_port': proxy_port,
+        'proxy_user': proxy_user,
+        'proxy_pass': proxy_pass
+    }
+    background_js = replace_variables_in_js(background_js, variables_dict)
+
+    with zipfile.ZipFile(extension_file, 'w') as zp:
+        zp.writestr('manifest.json', manifest_json)
+        zp.writestr('background.js', background_js)
+
+
+def get_my_ip(driver):
+    origin_tab = driver.current_window_handle
+    driver.execute_script("window.open('', '_blank');")
+    driver.switch_to.window(driver.window_handles[-1])
+
+    driver.get('https://api.ipify.org/?format=json')
+
+    ip_row = driver.find_element(By.XPATH, '//body').text
+    ip = json.loads(ip_row)['ip']
+
+    driver.close()
+    driver.switch_to.window(origin_tab)
+
+    return ip
+
+
+def proxy_is_working(driver, host: str):
+    ip = get_my_ip(driver)
+
+    if ip == host:
+        return True
+    else:
+        return False

requirements.txt

@@ -1,3 +1,15 @@
 selenium >=4.0.0, < 5.0.0
 gradio>=3.40.1
 Pillow>=8.3.1,<9.0
+googletrans==4.0.0rc1
+moviepy==1.0.3
+SpeechRecognition
+glob2
+spacy
+voicerss_tts
+requests
+fakeyou
+openai==0.27.0
+pixabay==0.0.4
+ffmpeg-python
+tiktok_uploader

screen.py

@@ -0,0 +1,35 @@
+import gradio as gr
+from selenium import webdriver
+from selenium.common.exceptions import WebDriverException
+from PIL import Image
+from io import BytesIO
+
+def take_screenshot(url):
+    options = webdriver.ChromeOptions()
+    options.add_argument('--headless')
+    options.add_argument('--no-sandbox')
+    options.add_argument('--disable-dev-shm-usage')
+
+    try:
+        wd = webdriver.Chrome(options=options)
+        wd.set_window_size(1080, 720)  # Adjust the window size here
+        wd.get(url)
+        wd.implicitly_wait(10)
+        screenshot = wd.get_screenshot_as_png()
+    except WebDriverException as e:
+        return Image.new('RGB', (1, 1))
+    finally:
+        if wd:
+            wd.quit()
+
+    return Image.open(BytesIO(screenshot))
+
+iface = gr.Interface(
+    fn=take_screenshot,
+    inputs=gr.inputs.Textbox(label="Website URL", default="https://kargaranamir.github.io"),
+    outputs=gr.Image(type="pil", height=360, width=540),  # Adjust the image size here
+    title="Website Screenshot",
+    description="Take a screenshot of a website.",
+)
+
+iface.launch()

srt.py

@@ -0,0 +1,5 @@
+import ffmpeg
+
+input = ffmpeg.input('ninja300123.mp4')
+output = ffmpeg.output(input, 'outputxd.mp4', vf="drawtext=text='Hola Mundo':x=10:y=H-th-10:fontsize=24:fontcolor=white")
+output.run()

upload.py

@@ -0,0 +1,706 @@
+"""
+`tiktok_uploader` module for uploading videos to TikTok
+
+Key Functions
+-------------
+upload_video : Uploads a single TikTok video
+upload_videos : Uploads multiple TikTok videos
+"""
+from os.path import abspath, exists
+from typing import List
+import time
+import pytz
+import datetime
+
+from selenium.webdriver.common.by import By
+
+from selenium.webdriver.common.action_chains import ActionChains
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.common.keys import Keys
+
+from tiktok_uploader.browsers import get_browser
+from tiktok_uploader.auth import AuthBackend
+from tiktok_uploader import logger
+from tiktok_uploader.utils import bold, green
+import toml
+config = toml.load("./config.toml")
+from proxy_auth_extension.proxy_auth_extension import proxy_is_working
+
+
+def upload_video(filename=None, description='', schedule: datetime.datetime = None, username='',
+                 password='', cookies='', sessionid=None, cookies_list=None, cookies_str=None, proxy=None, *args, **kwargs):
+    """
+    Uploads a single TikTok video.
+
+    Conder using `upload_videos` if using multiple videos
+
+    Parameters
+    ----------
+    filename : str
+        The path to the video to upload
+    description : str
+        The description to set for the video
+    schedule: datetime.datetime
+        The datetime to schedule the video, must be naive or aware with UTC timezone, if naive it will be aware with UTC timezone
+    cookies : str
+        The cookies to use for uploading
+    sessionid: str
+        The `sessionid` is the only required cookie for uploading,
+            but it is recommended to use all cookies to avoid detection
+    """
+    auth = AuthBackend(username=username, password=password, cookies=cookies,
+                       cookies_list=cookies_list, cookies_str=cookies_str, sessionid=sessionid)
+
+    return upload_videos(
+            videos=[ { 'path': filename, 'description': description, 'schedule': schedule } ],
+            auth=auth,
+            proxy=proxy,
+            *args, **kwargs
+        )
+
+
+def upload_videos(videos: list = None, auth: AuthBackend = None, proxy: dict = None, browser='chrome',
+                  browser_agent=None, on_complete=None, headless=True, num_retires : int = 1, *args, **kwargs):
+    """
+    Uploads multiple videos to TikTok
+
+    Parameters
+    ----------
+    videos : list
+        A list of dictionaries containing the video's ('path') and description ('description')
+    proxy: dict
+        A dictionary containing the proxy user, pass, host and port
+    browser : str
+        The browser to use for uploading
+    browser_agent : selenium.webdriver
+        A selenium webdriver object to use for uploading
+    on_complete : function
+        A function to call when the upload is complete
+    headless : bool
+        Whether or not the browser should be run in headless mode
+    num_retries : int
+        The number of retries to attempt if the upload fails
+    options : SeleniumOptions
+        The options to pass into the browser -> custom privacy settings, etc.
+    *args :
+        Additional arguments to pass into the upload function
+    **kwargs :
+        Additional keyword arguments to pass into the upload function
+
+    Returns
+    -------
+    failed : list
+        A list of videos which failed to upload
+    """
+    videos = _convert_videos_dict(videos)
+
+    if videos and len(videos) > 1:
+        logger.debug("Uploading %d videos", len(videos))
+
+    if not browser_agent: # user-specified browser agent
+        logger.debug('Create a %s browser instance %s', browser,
+                    'in headless mode' if headless else '')
+        driver = get_browser(name=browser, headless=headless, proxy=proxy, *args, **kwargs)
+    else:
+        logger.debug('Using user-defined browser agent')
+        driver = browser_agent
+    if proxy:
+        if proxy_is_working(driver, proxy['host']):
+            logger.debug(green('Proxy is working'))
+        else:
+            logger.error('Proxy is not working')
+            driver.quit()
+            raise Exception('Proxy is not working')
+    driver = auth.authenticate_agent(driver)
+
+    failed = []
+    # uploads each video
+    for video in videos:
+        try:
+            path = abspath(video.get('path'))
+            description = video.get('description', '')
+            schedule = video.get('schedule', None)
+
+            logger.debug('Posting %s%s', bold(video.get('path')),
+            f'\n{" " * 15}with description: {bold(description)}' if description else '')
+
+            # Video must be of supported type
+            if not _check_valid_path(path):
+                print(f'{path} is invalid, skipping')
+                failed.append(video)
+                continue
+
+            # Video must have a valid datetime for tiktok's scheduler
+            if schedule:
+                timezone = pytz.UTC
+                if schedule.tzinfo is None:
+                    schedule = schedule.astimezone(timezone)
+                elif int(schedule.utcoffset().total_seconds()) == 0:  # Equivalent to UTC
+                    schedule = timezone.localize(schedule)
+                else:
+                    print(f'{schedule} is invalid, the schedule datetime must be naive or aware with UTC timezone, skipping')
+                    failed.append(video)
+                    continue
+
+                valid_tiktok_minute_multiple = 5
+                schedule = _get_valid_schedule_minute(schedule, valid_tiktok_minute_multiple)
+                if not _check_valid_schedule(schedule):
+                    print(f'{schedule} is invalid, the schedule datetime must be as least 20 minutes in the future, and a maximum of 10 days, skipping')
+                    failed.append(video)
+                    continue
+
+            complete_upload_form(driver, path, description, schedule,
+                                 num_retires=num_retires, headless=headless,
+                                 *args, **kwargs)
+        except Exception as exception:
+            logger.error('Failed to upload %s', path)
+            logger.error(exception)
+            failed.append(video)
+
+        if on_complete is callable: # calls the user-specified on-complete function
+            on_complete(video)
+
+    if config['quit_on_end']:
+        driver.quit()
+
+    return failed
+
+
+def complete_upload_form(driver, path: str, description: str, schedule: datetime.datetime, headless=True, *args, **kwargs) -> None:
+    """
+    Actually uploades each video
+
+    Parameters
+    ----------
+    driver : selenium.webdriver
+        The selenium webdriver to use for uploading
+    path : str
+        The path to the video to upload
+    """
+    _go_to_upload(driver)
+    _set_video(driver, path=path, **kwargs)
+    _set_interactivity(driver, **kwargs)
+    _set_description(driver, description)
+    if schedule:
+        _set_schedule_video(driver, schedule)
+    _post_video(driver)
+
+
+def _go_to_upload(driver) -> None:
+    """
+    Navigates to the upload page, switches to the iframe and waits for it to load
+
+    Parameters
+    ----------
+    driver : selenium.webdriver
+    """
+    logger.debug(green('Navigating to upload page'))
+
+    driver.get(config['paths']['upload'])
+
+    # changes to the iframe
+    iframe_selector = EC.presence_of_element_located(
+        (By.XPATH, config['selectors']['upload']['iframe'])
+        )
+    iframe = WebDriverWait(driver, config['explicit_wait']).until(iframe_selector)
+    driver.switch_to.frame(iframe)
+
+    # waits for the iframe to load
+    root_selector = EC.presence_of_element_located((By.ID, 'root'))
+    WebDriverWait(driver, config['explicit_wait']).until(root_selector)
+
+
+def _set_description(driver, description: str) -> None:
+    """
+    Sets the description of the video
+
+    Parameters
+    ----------
+    driver : selenium.webdriver
+    description : str
+        The description to set
+    """
+    if description is None:
+        # if no description is provided, filename
+        return
+
+    logger.debug(green('Setting description'))
+
+    saved_description = description # save the description in case it fails
+
+    desc = driver.find_element(By.XPATH, config['selectors']['upload']['description'])
+
+    # desc populates with filename before clearing
+    WebDriverWait(driver, config['explicit_wait']).until(lambda driver: desc.text != '')
+
+    _clear(desc)
+
+    try:
+        while description:
+            nearest_mention = description.find('@')
+            nearest_hash = description.find('#')
+
+            if nearest_mention == 0 or nearest_hash == 0:
+                desc.send_keys('@' if nearest_mention == 0 else '#')
+
+                # wait for the frames to load
+                time.sleep(config['implicit_wait'])
+
+                name = description[1:].split(' ')[0]
+                if nearest_mention == 0: # @ case
+                    mention_xpath = config['selectors']['upload']['mention_box']
+                    condition = EC.presence_of_element_located((By.XPATH, mention_xpath))
+                    mention_box = WebDriverWait(driver, config['explicit_wait']).until(condition)
+                    mention_box.send_keys(name)
+                else:
+                    desc.send_keys(name)
+
+                time.sleep(config['implicit_wait'])
+
+                if nearest_mention == 0: # @ case
+                    mention_xpath = config['selectors']['upload']['mentions'].format('@' + name)
+                    condition = EC.presence_of_element_located((By.XPATH, mention_xpath))
+                else:
+                    hashtag_xpath = config['selectors']['upload']['hashtags'].format(name)
+                    condition = EC.presence_of_element_located((By.XPATH, hashtag_xpath))
+
+                elem = WebDriverWait(driver, config['explicit_wait']).until(condition)
+
+                ActionChains(driver).move_to_element(elem).click(elem).perform()
+
+                description = description[len(name) + 2:]
+            else:
+                min_index = _get_splice_index(nearest_mention, nearest_hash, description)
+
+                desc.send_keys(description[:min_index])
+                description = description[min_index:]
+    except Exception as exception:
+        print('Failed to set description: ', exception)
+        _clear(desc)
+        desc.send_keys(saved_description) # if fail, use saved description
+
+
+def _clear(element) -> None:
+    """
+    Clears the text of the element (an issue with the TikTok website when automating)
+
+    Parameters
+    ----------
+    element
+        The text box to clear
+    """
+    element.send_keys(2 * len(element.text) * Keys.BACKSPACE)
+
+
+def _set_video(driver, path: str = '', num_retries: int = 3, **kwargs) -> None:
+    """
+    Sets the video to upload
+
+    Parameters
+    ----------
+    driver : selenium.webdriver
+    path : str
+        The path to the video to upload
+    num_retries : number of retries (can occassionally fail)
+    """
+    # uploades the element
+    logger.debug(green('Uploading video file'))
+
+    for _ in range(num_retries):
+        try:
+            logger.debug(green('Uploading video file 1'))
+            upload_box = driver.find_element(
+                By.XPATH, config['selectors']['upload']['upload_video']
+            )
+            logger.debug(green('Uploading video file 2'))
+            upload_box.send_keys(path)
+            logger.debug(green('Uploading video file 3'))
+            # waits for the upload progress bar to disappear
+            upload_progress = EC.presence_of_element_located(
+                (By.XPATH, config['selectors']['upload']['upload_in_progress'])
+                )
+            logger.debug(green('Uploading video file 4'))
+            WebDriverWait(driver, config['implicit_wait']).until(upload_progress)
+            WebDriverWait(driver, config['explicit_wait']).until_not(upload_progress)
+            logger.debug(green('Uploading video file 5'))
+            # waits for the video to upload
+            upload_confirmation = EC.presence_of_element_located(
+                (By.XPATH, config['selectors']['upload']['upload_confirmation'])
+                )
+            logger.debug(green('Uploading video file 6'))
+            # An exception throw here means the video failed to upload an a retry is needed
+            WebDriverWait(driver, config['explicit_wait']).until(upload_confirmation)
+            logger.debug(green('Uploading video file 7'))
+            # wait until a non-draggable image is found
+            process_confirmation = EC.presence_of_element_located(
+                (By.XPATH, config['selectors']['upload']['process_confirmation'])
+                )
+            logger.debug(green('Uploading video file 8'))
+            WebDriverWait(driver, config['explicit_wait']).until(process_confirmation)
+            logger.debug(green('Uploading video file 9'))
+            return
+        except Exception as exception:
+            print(exception)
+
+    raise FailedToUpload()
+
+
+def _set_interactivity(driver, comment=True, stitch=True, duet=True, *args, **kwargs) -> None:
+    """
+    Sets the interactivity settings of the video
+
+    Parameters
+    ----------
+    driver : selenium.webdriver
+    comment : bool
+        Whether or not to allow comments
+    stitch : bool
+        Whether or not to allow stitching
+    duet : bool
+        Whether or not to allow duets
+    """
+    try:
+        logger.debug(green('Setting interactivity settings'))
+
+        comment_box = driver.find_element(By.XPATH, config['selectors']['upload']['comment'])
+        stitch_box = driver.find_element(By.XPATH, config['selectors']['upload']['stitch'])
+        duet_box = driver.find_element(By.XPATH, config['selectors']['upload']['duet'])
+
+        # xor the current state with the desired state
+        if comment ^ comment_box.is_selected():
+            comment_box.click()
+
+        if stitch ^ stitch_box.is_selected():
+            stitch_box.click()
+
+        if duet ^ duet_box.is_selected():
+            duet_box.click()
+
+    except Exception as _:
+        logger.error('Failed to set interactivity settings')
+
+
+def _set_schedule_video(driver, schedule: datetime.datetime) -> None:
+    """
+    Sets the schedule of the video
+
+    Parameters
+    ----------
+    driver : selenium.webdriver
+    schedule : datetime.datetime
+        The datetime to set
+    """
+
+    logger.debug(green('Setting schedule'))
+
+    driver_timezone = __get_driver_timezone(driver)
+    schedule = schedule.astimezone(driver_timezone)
+
+    month = schedule.month
+    day = schedule.day
+    hour = schedule.hour
+    minute = schedule.minute
+
+    try:
+        switch = driver.find_element(By.XPATH, config['selectors']['schedule']['switch'])
+        switch.click()
+        __date_picker(driver, month, day)
+        __time_picker(driver, hour, minute)
+    except Exception as e:
+        msg = f'Failed to set schedule: {e}'
+        print(msg)
+        logger.error(msg)
+        raise FailedToUpload()
+
+
+
+def __date_picker(driver, month: int, day: int) -> None:
+    logger.debug(green('Picking date'))
+
+    condition = EC.presence_of_element_located(
+        (By.XPATH, config['selectors']['schedule']['date_picker'])
+        )
+    date_picker = WebDriverWait(driver, config['implicit_wait']).until(condition)
+    date_picker.click()
+
+    condition = EC.presence_of_element_located(
+        (By.XPATH, config['selectors']['schedule']['calendar'])
+    )
+    calendar = WebDriverWait(driver, config['implicit_wait']).until(condition)
+
+    calendar_month = driver.find_element(By.XPATH, config['selectors']['schedule']['calendar_month']).text
+    n_calendar_month = datetime.datetime.strptime(calendar_month, '%B').month
+    if n_calendar_month != month:  # Max can be a month before or after
+        if n_calendar_month < month:
+            arrow = driver.find_elements(By.XPATH, config['selectors']['schedule']['calendar_arrows'])[-1]
+        else:
+            arrow = driver.find_elements(By.XPATH, config['selectors']['schedule']['calendar_arrows'])[0]
+        arrow.click()
+    valid_days = driver.find_elements(By.XPATH, config['selectors']['schedule']['calendar_valid_days'])
+
+    day_to_click = None
+    for day_option in valid_days:
+        if int(day_option.text) == day:
+            day_to_click = day_option
+            break
+    if day_to_click:
+        day_to_click.click()
+    else:
+        raise Exception('Day not found in calendar')
+
+    __verify_date_picked_is_correct(driver, month, day)
+
+
+def __verify_date_picked_is_correct(driver, month: int, day: int):
+    date_selected = driver.find_element(By.XPATH, config['selectors']['schedule']['date_picker']).text
+    date_selected_month = int(date_selected.split('-')[1])
+    date_selected_day = int(date_selected.split('-')[2])
+
+    if date_selected_month == month and date_selected_day == day:
+        logger.debug(green('Date picked correctly'))
+    else:
+        msg = f'Something went wrong with the date picker, expected {month}-{day} but got {date_selected_month}-{date_selected_day}'
+        logger.error(msg)
+        raise Exception(msg)
+
+
+def __time_picker(driver, hour: int, minute: int) -> None:
+    logger.debug(green('Picking time'))
+
+    condition = EC.presence_of_element_located(
+        (By.XPATH, config['selectors']['schedule']['time_picker'])
+        )
+    time_picker = WebDriverWait(driver, config['implicit_wait']).until(condition)
+    time_picker.click()
+
+    condition = EC.presence_of_element_located(
+        (By.XPATH, config['selectors']['schedule']['time_picker_container'])
+    )
+    time_picker_container = WebDriverWait(driver, config['implicit_wait']).until(condition)
+
+    # 00 = 0, 01 = 1, 02 = 2, 03 = 3, 04 = 4, 05 = 5, 06 = 6, 07 = 7, 08 = 8, 09 = 9, 10 = 10, 11 = 11, 12 = 12,
+    # 13 = 13, 14 = 14, 15 = 15, 16 = 16, 17 = 17, 18 = 18, 19 = 19, 20 = 20, 21 = 21, 22 = 22, 23 = 23
+    hour_options = driver.find_elements(By.XPATH, config['selectors']['schedule']['timepicker_hours'])
+    # 00 == 0, 05 == 1, 10 == 2, 15 == 3, 20 == 4, 25 == 5, 30 == 6, 35 == 7, 40 == 8, 45 == 9, 50 == 10, 55 == 11
+    minute_options = driver.find_elements(By.XPATH, config['selectors']['schedule']['timepicker_minutes'])
+
+    hour_to_click = hour_options[hour]
+    minute_option_correct_index = int(minute / 5)
+    minute_to_click = minute_options[minute_option_correct_index]
+
+    driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'nearest'});", hour_to_click)
+    hour_to_click.click()
+    driver.execute_script("arguments[0].scrollIntoView({block: 'center', inline: 'nearest'});", minute_to_click)
+    minute_to_click.click()
+
+    # click somewhere else to close the time picker
+    time_picker.click()
+
+    time.sleep(.5)  # wait for the DOM change
+    __verify_time_picked_is_correct(driver, hour, minute)
+
+
+def __verify_time_picked_is_correct(driver, hour: int, minute: int):
+    time_selected = driver.find_element(By.XPATH, config['selectors']['schedule']['time_picker_text']).text
+    time_selected_hour = int(time_selected.split(':')[0])
+    time_selected_minute = int(time_selected.split(':')[1])
+
+    if time_selected_hour == hour and time_selected_minute == minute:
+        logger.debug(green('Time picked correctly'))
+    else:
+        msg = f'Something went wrong with the time picker, ' \
+              f'expected {hour:02d}:{minute:02d} ' \
+              f'but got {time_selected_hour:02d}:{time_selected_minute:02d}'
+        logger.error(msg)
+        raise Exception(msg)
+
+
+def _post_video(driver) -> None:
+    """
+    Posts the video by clicking the post button
+
+    Parameters
+    ----------
+    driver : selenium.webdriver
+    """
+    logger.debug(green('Clicking the post button'))
+
+    post = driver.find_element(By.XPATH, config['selectors']['upload']['post'])
+    post.click()
+
+    # waits for the video to upload
+    post_confirmation = EC.presence_of_element_located(
+        (By.XPATH, config['selectors']['upload']['post_confirmation'])
+        )
+    WebDriverWait(driver, config['explicit_wait']).until(post_confirmation)
+
+    logger.debug(green('Video posted successfully'))
+
+
+# HELPERS
+
+def _check_valid_path(path: str) -> bool:
+    """
+    Returns whether or not the filetype is supported by TikTok
+    """
+    return exists(path) and path.split('.')[-1] in config['supported_file_types']
+
+
+def _get_valid_schedule_minute(schedule, valid_multiple) -> datetime.datetime:
+    """
+    Returns a datetime.datetime with valid minute for TikTok
+    """
+    if _is_valid_schedule_minute(schedule.minute, valid_multiple):
+        return schedule
+    else:
+        return _set_valid_schedule_minute(schedule, valid_multiple)
+
+
+def _is_valid_schedule_minute(minute, valid_multiple) -> bool:
+    if minute % valid_multiple != 0:
+        return False
+    else:
+        return True
+
+
+def _set_valid_schedule_minute(schedule, valid_multiple) -> datetime.datetime:
+    minute = schedule.minute
+
+    remainder = minute % valid_multiple
+    integers_to_valid_multiple = 5 - remainder
+    schedule += datetime.timedelta(minutes=integers_to_valid_multiple)
+
+    return schedule
+
+
+def _check_valid_schedule(schedule: datetime.datetime) -> bool:
+    """
+    Returns if the schedule is supported by TikTok
+    """
+    valid_tiktok_minute_multiple = 5
+    margin_to_complete_upload_form = 5
+
+    datetime_utc_now = pytz.UTC.localize(datetime.datetime.utcnow())
+    min_datetime_tiktok_valid = datetime_utc_now + datetime.timedelta(minutes=15)
+    min_datetime_tiktok_valid += datetime.timedelta(minutes=margin_to_complete_upload_form)
+    max_datetime_tiktok_valid = datetime_utc_now + datetime.timedelta(days=10)
+    if schedule < min_datetime_tiktok_valid \
+            or schedule > max_datetime_tiktok_valid:
+        return False
+    elif not _is_valid_schedule_minute(schedule.minute, valid_tiktok_minute_multiple):
+        return False
+    else:
+        return True
+
+
+def _get_splice_index(nearest_mention: int, nearest_hashtag: int, description: str) -> int:
+    """
+    Returns the index to splice the description at
+
+    Parameters
+    ----------
+    nearest_mention : int
+        The index of the nearest mention
+    nearest_hashtag : int
+        The index of the nearest hashtag
+
+    Returns
+    -------
+    int
+        The index to splice the description at
+    """
+    if nearest_mention == -1 and nearest_hashtag == -1:
+        return len(description)
+    elif nearest_hashtag == -1:
+        return nearest_mention
+    elif nearest_mention == -1:
+        return nearest_hashtag
+    else:
+        return min(nearest_mention, nearest_hashtag)
+
+def _convert_videos_dict(videos_list_of_dictionaries) -> List:
+    """
+    Takes in a videos dictionary and converts it.
+
+    This allows the user to use the wrong stuff and thing to just work
+    """
+    if not videos_list_of_dictionaries:
+        raise RuntimeError("No videos to upload")
+
+    valid_path = config['valid_path_names']
+    valid_description = config['valid_descriptions']
+
+    correct_path = valid_path[0]
+    correct_description = valid_description[0]
+
+    def intersection(lst1, lst2):
+        """ return the intersection of two lists """
+        return list(set(lst1) & set(lst2))
+
+    return_list = []
+    for elem in videos_list_of_dictionaries:
+        # preprocesses the dictionary
+        elem = {k.strip().lower(): v for k, v in elem.items()}
+
+        keys = elem.keys()
+        path_intersection = intersection(valid_path, keys)
+        description_interesection = intersection(valid_description, keys)
+
+        if path_intersection:
+            # we have a path
+            path = elem[path_intersection.pop()]
+
+            if not _check_valid_path(path):
+                raise RuntimeError("Invalid path: " + path)
+
+            elem[correct_path] = path
+        else:
+            # iterates over the elem and find a key which is a path with a valid extension
+            for _, value in elem.items():
+                if _check_valid_path(value):
+                    elem[correct_path] = value
+                    break
+            else:
+                # no valid path found
+                raise RuntimeError("Path not found in dictionary: " + str(elem))
+
+        if description_interesection:
+            # we have a description
+            elem[correct_description] = elem[description_interesection.pop()]
+        else:
+            # iterates over the elem and finds a description which is not a valid path
+            for _, value in elem.items():
+                if not _check_valid_path(value):
+                    elem[correct_description] = value
+                    break
+            else:
+                elem[correct_description] = '' # null description is fine
+
+        return_list.append(elem)
+
+    return return_list
+
+def __get_driver_timezone(driver) -> pytz.timezone:
+    """
+    Returns the timezone of the driver
+    """
+    timezone_str = driver.execute_script("return Intl.DateTimeFormat().resolvedOptions().timeZone")
+    return pytz.timezone(timezone_str)
+
+class DescriptionTooLong(Exception):
+    """
+    A video description longer than the maximum allowed by TikTok's website (not app) uploader
+    """
+
+    def __init__(self, message=None):
+        super().__init__(message or self.__doc__)
+
+
+class FailedToUpload(Exception):
+    """
+    A video failed to upload
+    """
+
+    def __init__(self, message=None):
+        super().__init__(message or self.__doc__)

utils.py

@@ -0,0 +1,37 @@
+from pydub import AudioSegment
+#from pydub.utils import mediainfo
+from pydub.utils import make_chunks
+import math
+#flac_audio = AudioSegment.from_file("sample.flac", "flac")
+#flac_audio.export("audio.wav", format="wav")
+def split_audio_wav(filename):
+    myaudio = AudioSegment.from_file(filename , "wav")
+    channel_count = myaudio.channels    #Get channels
+    sample_width = myaudio.sample_width #Get sample width
+    duration_in_sec = len(myaudio) / 1000#Length of audio in sec
+    sample_rate = myaudio.frame_rate
+    print("sample_width=", sample_width) 
+    print("channel_count=", channel_count)
+    print("duration_in_sec=", duration_in_sec) 
+    print("frame_rate=", sample_rate)
+    bit_rate =16  #assumption , you can extract from mediainfo("test.wav") dynamically
+    wav_file_size = (sample_rate * bit_rate * channel_count * duration_in_sec) / 8
+    print("wav_file_size = ",wav_file_size)
+    file_split_size = 40000000  # 40mb OR 40, 000, 000 bytes
+    total_chunks =  wav_file_size // file_split_size
+    #Get chunk size by following method #There are more than one ofcourse
+    #for  duration_in_sec (X) -->  wav_file_size (Y)
+    #So   whats duration in sec  (K) --> for file size of 40Mb
+    #  K = X * 40Mb / Y
+    chunk_length_in_sec = math.ceil((duration_in_sec * 40000000 ) /wav_file_size)   #in sec
+    chunk_length_ms = chunk_length_in_sec * 1000
+    chunks = make_chunks(myaudio, chunk_length_ms)
+    number_chunks=len(chunks)
+    chunks_list=[]
+    #Export all of the individual chunks as wav files
+    for i, chunk in enumerate(chunks):
+        chunk_name = "chunk{0}.wav".format(i)
+        print("exporting", chunk_name)
+        chunk.export(chunk_name, format="wav")
+        chunks_list.append(chunk_name)
+    return chunks_list