Anjay

app.py

@@ -6,7 +6,7 @@ from pornhub import pornhub
 from other import cut_video, session, convert_size
 
 # Navigasi Sidebar
-options = ['Youtube', 'Pornhub', 'Iwara', 'Mega', 'Rule34', 'Paipancon', 'Trailer']
+options = ['Youtube', 'Pornhub (Not Work)', 'Iwara (Not Work)', 'Mega', 'Rule34', 'Paipancon', 'Trailer']
 with st.sidebar:
     selected = option_menu("Video Downloader", options, 
         icons=['play', 'fire', 'star', 'moon','gear', 'house', 'lightning'], menu_icon="cast", default_index=0)

bunkrr.py

@@ -0,0 +1,35 @@
+from bs4 import BeautifulSoup
+import re
+
+def get_info_bunkrr(soup: BeautifulSoup):
+    # Mencari judul video di elemen <title>
+    title = soup.find("title")
+    if title:
+        video_title = title.text
+
+        # Ubah '&amp;' menjadi '&'
+        video_title = video_title.replace('&amp;', '&')
+
+        # Jika ada karakter '-' maka cari '-' paling belakang dan hapus mulai dari itu sampai ke belakang
+        if '-' in video_title:
+            last_dash_index = video_title.rfind('-')
+            video_title = video_title[:last_dash_index]
+
+        # Sisa dari karakter '-' ubah menjadi ' '
+        video_title = video_title.replace('-', ' ')
+
+        # Mencari link download yang berawalan https dan berakhiran .mp4
+        link_download = soup.find("source", src=re.compile(r'^https.*\.mp4$'))
+        if link_download:
+            link_download = link_download['src']
+
+            # Ubah '&amp;' menjadi '&'
+            link_download = link_download.replace('&amp;', '&')
+            print(link_download)
+        else:
+            link_download = ''
+
+        return video_title, link_download
+    else:
+        print("Tidak ditemukan elemen <title>")
+        return '', ''

iwara.py

@@ -0,0 +1,353 @@
+import requests, hashlib, os
+
+api_url = 'https://api.iwara.tv'
+file_url = 'https://files.iwara.tv'
+
+class BearerAuth(requests.auth.AuthBase):
+    """Bearer Authentication"""
+    def __init__(self, token):
+        self.token = token
+
+    def __call__(self, r):
+        r.headers['Authorization'] = 'Bearer ' + self.token
+        return r
+
+class ApiClient:
+    def __init__(self, email, password):
+        self.email = email
+        self.password = password
+
+        # self.headers = {
+        # 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36',
+        # 'X-Version': 's'
+        # }
+
+        # API
+        self.api_url = api_url
+        self.file_url = file_url
+        self.timeout = 30
+        # self.max_retries = 5
+        self.download_timeout = 300
+        self.token = None
+
+        # HTML
+        # self.html_url = html_url
+
+        # Cloudscraper
+        # self.scraper = cloudscraper.create_scraper(browser={'browser': 'firefox','platform': 'windows','mobile': False}, 
+        #                                         #    interpreter = 'nodejs'
+        #                                         )
+        # Requests-html
+        # self.session = HTMLSession()
+
+    def login(self) -> requests.Response:
+        url = self.api_url + '/user/login'
+        json = {'email': self.email, 'password': self.password}
+        r = requests.post(url, json=json, timeout=self.timeout)
+        try:
+            self.token = r.json()['token']
+            print('API Login success')
+        except:
+            print('API Login failed')
+
+        # try:
+        #     # Cloudscraper
+        #     # r = self.scraper.post(url, json=json, headers=self.headers, timeout=self.timeout)
+
+        #     # Requests-html
+        #     r = self.session.post(url, json=json, headers=self.headers, timeout=self.timeout)
+        # except:
+        #     print('BS4 Login failed')
+
+        return r
+
+    # limit query is not working
+    def get_videos(self, sort = 'date', rating = 'all', page = 0, limit = 32, subscribed = False) -> requests.Response:
+        """# Get new videos from iwara.tv
+        - sort: date, trending, popularity, views, likes
+        - rating: all, general, ecchi
+        """
+        url = self.api_url + '/videos'
+        params = {'sort': sort, 
+                  'rating': rating, 
+                  'page': page, 
+                  'limit': limit,
+                  'subscribed': 'true' if subscribed else 'false',
+                  }
+        if self.token is None:
+            r = requests.get(url, params=params, timeout=self.timeout)
+        else:
+
+            # Verbose Debug
+            # request = requests.Request('GET', url, params=params, auth=BearerAuth(self.token))
+            # print(request.prepare().method, request.prepare().url, request.prepare().headers, request.prepare().body, sep='\n')
+            # r = requests.Session().send(request.prepare())
+
+            r = requests.get(url, params=params, auth=BearerAuth(self.token), timeout=self.timeout)
+
+        #Debug
+        print("[DEBUG] get_videos response:", r)
+
+        return r
+    
+    def get_video(self, video_id) -> requests.Response:
+        """# Get video info from iwara.tv
+        """
+        url = self.api_url + '/video/' + video_id
+
+        if self.token is None:
+            r = requests.get(url, timeout=self.timeout)
+        else:
+            r = requests.get(url, auth=BearerAuth(self.token), timeout=self.timeout)
+
+        #Debug
+        print("[DEBUG] get_video response:", r)
+
+        return r
+    
+    def download_video_thumbnail(self, video_id) -> str:
+        """# Download video thumbnail from iwara.tv
+        """
+        video = self.get_video(video_id).json()
+
+        file_id = video['file']['id']
+        thumbnail_id = video['thumbnail']
+        
+        url = self.file_url + '/image/original/' + file_id + '/thumbnail-{:02d}.jpg'.format(thumbnail_id)
+
+        thumbnail_file_name = video_id + '.jpg'
+
+        if (os.path.exists(thumbnail_file_name)):
+            print(f"Video ID {video_id} thumbnail already downloaded, skipped downloading. ")
+            return thumbnail_file_name
+        
+        print(f"Downloading thumbnail for video ID: {video_id} ...")
+        with open(thumbnail_file_name, "wb") as f:
+            for chunk in requests.get(url).iter_content(chunk_size=1024):
+                if chunk:
+                    f.write(chunk)
+                    f.flush()
+
+        return thumbnail_file_name
+
+    def download_video(self, video_id) -> str:
+        """# Download video from iwara.tv
+        """
+
+        # html
+        # url = self.html_url + '/video/' + video_id
+
+        # Cloudscraer
+        # html = self.scraper.get(url, auth=BearerAuth(self.token), timeout=self.timeout).text
+
+        # Requests-html
+        # html = self.session.get(url, auth=BearerAuth(self.token), timeout=self.timeout).text
+
+        # print(html)
+        # html = BeautifulSoup(, 'html.parser')
+        # downloadLink = html.find('div', class_='dropdown_content')
+        # print(downloadLink)
+
+        # API
+        try:
+            video = self.get_video(video_id).json()
+        except Exception as e:
+            raise Exception(f"Failed to get video info for video ID: {video_id}, error: {e}")
+
+        #Debug
+        print(video)
+
+        url = video['fileUrl']
+        file_id = video['file']['id']
+        expires = url.split('/')[4].split('?')[1].split('&')[0].split('=')[1]
+
+        # IMPORTANT: This might change in the future.
+        SHA_postfix = "_5nFp9kmbNnHdAFhaqMvt"
+
+        SHA_key = file_id + "_" + expires + SHA_postfix
+        hash = hashlib.sha1(SHA_key.encode('utf-8')).hexdigest()
+
+        headers = {"X-Version": hash}
+
+        resources = requests.get(url, headers=headers, auth=BearerAuth(self.token), timeout=self.timeout).json()
+        
+        #Debug
+        print(resources)
+
+        resources_by_quality = [None for i in range(10)]
+
+        for resource in resources:
+            if resource['name'] == 'Source':
+                resources_by_quality[0] = resource
+            # elif resource['name'] == '1080':
+            #     resources_by_quality[1] = resource
+            # elif resource['name'] == '720':
+            #     resources_by_quality[2] = resource
+            # elif resource['name'] == '480':
+            #     resources_by_quality[3] = resource
+            # elif resource['name'] == '540':
+                # resources_by_quality[4] = resource
+            # elif resource['name'] == '360':
+                # resources_by_quality[5] = resource
+
+        for resource in resources_by_quality:
+            if resource is not None:
+                #Debug
+                print(resource)
+
+                download_link = "https:" + resource['src']['download']
+                file_type = resource['type'].split('/')[1]
+
+                video_file_name = video_id + '.' + file_type
+
+                if (os.path.exists(video_file_name)):
+                    print(f"Video ID {video_id} Already downloaded, skipped downloading. ")
+                    return video_file_name
+
+                print(f"Downloading video ID: {video_id} ...")
+                try:
+                    with open(video_file_name, "wb") as f:
+                        for chunk in requests.get(download_link).iter_content(chunk_size=1024):
+                            if chunk:
+                                f.write(chunk)
+                                f.flush()
+                    return video_file_name
+                except Exception as e:
+                    os.remove(video_file_name)
+                    raise Exception(f"Failed to download video ID: {video_id}, error: {e}")
+
+            
+        raise Exception("No video with Source quality found")
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+### download video from iwara.tv
+### usage: python iwara [url]
+### by AngelBottomless @ github
+# download from iwara page
+import requests
+# use selenium to get video url
+from selenium import webdriver
+import argparse
+
+def download_video(url):
+    # save video to local
+    filename = url.split('/')[-1] + '.mp4'
+    # get video
+    driver = run_webdriver(url)
+    click_accept(driver)
+    driver.implicitly_wait(2)
+    click_play(driver)
+    url = find_video_url(driver)
+    # download video
+    r = requests.get(url)
+    with open(filename, 'wb') as f:
+        f.write(r.content)
+    # close driver
+    driver.close()
+
+def download_with_retry(url, retry=3):
+    # retry download
+    for _ in range(retry):
+        try:
+            download_video(url)
+            return True
+        except:
+            print('download failed, retrying...')
+            continue
+    return False
+
+def run_webdriver(url):
+    # use selenium to get video url
+    # mute chrome
+    chrome_options = webdriver.ChromeOptions()
+    chrome_options.add_argument("--mute-audio")
+    # run webdriver
+    driver = webdriver.Chrome(options=chrome_options)
+    driver.get(url)
+    driver.implicitly_wait(4)
+    return driver
+
+def click_accept(driver):
+    # xpath = /html/body/div[3]/div/div[2]/button[1]
+    button = driver.find_element('xpath', '/html/body/div[3]/div/div[2]/button[1]')
+    button.click()
+def click_play(driver):
+    # xpath = //*[@id="vjs_video_3"]/button
+    button = driver.find_element('xpath', '//*[@id="vjs_video_3"]/button')
+    button.click()
+
+def find_video_url(driver):
+    # xpath //*[@id="vjs_video_3_html5_api"]
+    #access 'src'
+    video = driver.find_element('xpath', '//*[@id="vjs_video_3_html5_api"]')
+    video_url = video.get_attribute('src')
+    return video_url
+
+def track_clipboard():
+    import pyperclip
+    import time
+    import subprocess
+    failed_urls = []
+    success_urls = set()
+    print('tracking clipboard...')
+    # loop to track clipboard
+    # if clipboard contains url, download video
+    # track every 1 second
+    previous = ''
+    # expect KeyboardInterrupt and return 0
+    try:
+        while True:
+            # get clipboard
+            clipboard = pyperclip.paste()
+            if clipboard != previous:
+                # if clipboard contains url
+                if 'iwara.tv' in clipboard:
+                    print('url detected, downloading...')
+                    # use subprocess to download video in background
+                    # ['python', '-m', 'iwara', clipboard]
+                    subprocess.Popen(['python', '-m', 'iwara', clipboard])
+                    print('download complete')
+                    previous = clipboard
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print('exiting...')
+        return 0
+
+if __name__ == '__main__':
+    failed_urls = []
+    success_urls = set()
+    import sys
+    # parse args
+    parser = argparse.ArgumentParser()
+    # track clipboard option, when 'track' is used, url is not required
+    parser.add_argument('-t', '--track', action='store_true', help='track clipboard for iwara url')
+    # add url argument, if not specified, use ''
+    parser.add_argument('url', nargs='?', default='', help='iwara url')
+    args = parser.parse_args()
+    # download video
+    if args.track:
+        track_clipboard()
+    elif 'iwara.tv' in args.url:
+        result = download_with_retry(args.url)
+        if not result:
+            print('download failed')
+            failed_urls.append(args.url)
+        else:
+            print('download complete')
+            success_urls.add(args.url)
+        if len(failed_urls) > 0:
+            print('failed urls:')
+            for url in failed_urls:
+                print(url)
+                # write in ./failed.txt
+                with open('failed.txt', 'a') as f:
+                    f.write(url + '\n')
+                sys.exit(1)
+    else:
+        print('invalid url')
+        sys.exit(1)

mega.py

@@ -0,0 +1,27 @@
+import os
+import shutil
+from mega import Mega
+from other import convert_videos
+
+def download_mega(name, directory, url):
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    mega = Mega()
+    m = mega.login()
+
+    # Download the file to a temporary location
+    file = m.download_url(url, dest_filename=name)
+
+    # Rename the file and move it to the specified directory
+    filename = os.path.join(directory, file)
+    shutil.move(file, filename)
+
+    return filename
+
+def mega(url, judul):
+    judul = judul + '.mp4'
+    download = '/home/user/app/Mega'
+    filename = download_mega(judul, download, url)
+    output_file = convert_videos(720, download)
+    return output_file

other.py

@@ -1,12 +1,22 @@
 import os
 import requests
 import time
+import math
+import re
+import shutil
+import json
+import subprocess
+import mimetypes
 from datetime import datetime, timedelta
 from moviepy.editor import VideoFileClip
 import streamlit as st
 from streamlit_option_menu import option_menu
+from collections import defaultdict
+from tqdm import tqdm
+from googletrans import Translator
+from bs4 import BeautifulSoup
 
-def start():
+def start_clock():
     start_time = None
     start_time = time.time()
     if start_time is not None:
@@ -69,4 +79,241 @@ def convert_size(size_bytes):
     while size_bytes >= 1024 and index < len(units) - 1:
         size_bytes /= 1024
         index += 1
-    return f"{size_bytes:.2f} {units[index]}"
+    return f"{size_bytes:.2f} {units[index]}"
+
+def add_space(name):
+    new_name = ''
+    for i in range(len(name)):
+        if i > 0 and name[i].isupper() and name[i-1].islower():
+            new_name += ' '
+        new_name += name[i]
+    return new_name
+
+def download_file(url, new_name, directory):
+    response = requests.get(url, stream=True)
+    content_type = response.headers.get("Content-Type")
+    extension = mimetypes.guess_extension(content_type)
+
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    filename = f"{directory}/{new_name}{extension}"
+    with open(filename, 'wb') as file:
+        total_size = int(response.headers.get("Content-Length", 0))
+        progress_bar = tqdm(total=total_size, unit="B", unit_scale=True, ncols=80)
+
+        for chunk in response.iter_content(chunk_size=1024):
+            if chunk:
+                file.write(chunk)
+                progress_bar.update(len(chunk))
+
+        progress_bar.close()
+
+    return filename
+
+def convert_japanese_to_romaji(text):
+    translator = Translator(service_urls=['translate.google.com'])
+    translation = translator.translate(text, src='ja', dest='ja')
+    return translation.pronunciation
+
+def translate_japanese_to_english(text):
+    translator = Translator(service_urls=['translate.google.com'])
+    translation = translator.translate(text, src='ja', dest='en')
+    return translation.text
+
+def get_video_resolution(input_file):
+    command = ['ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'json', input_file]
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode == 0:
+        video_info = json.loads(result.stdout)
+        width = video_info['streams'][0]['width']
+        height = video_info['streams'][0]['height']
+        return (width, height)
+    else:
+        print(f'Error getting video resolution: {result.stderr}')
+        return None
+
+def get_video_info(soup: BeautifulSoup):
+    # Mencari judul video di elemen meta dengan name="twitter:title"
+    title = soup.find("meta", attrs={"name": "twitter:title"})
+    if title:
+        video_title = title['content']
+
+        # Hapus semua karakter yang terdapat di dalam kurung siku (termasuk angka)
+        video_title = re.sub(r'\[[^\]]*\]', '', video_title)
+
+        # Hapus kata 'Cosplay '
+        video_title = video_title.replace('Cosplay ', '')
+
+        # Tukar posisi kalimat yang dipisahkan oleh ' - '
+        if ' - ' in video_title:
+            parts = video_title.split(' - ')
+            video_title = f"{parts[1]} - {parts[0]}"
+            actress = parts[0].lstrip()
+            series = parts[1].lstrip()
+        else:
+            actress = ''
+            series = ''
+
+        # Ubah dua spasi menjadi satu spasi
+        video_title = re.sub(r'\s{2,}', '', video_title)
+
+        print(f"Artis: {actress} dan Series: {series}")
+        return actress, series, title, video_title
+    else:
+        print("Tidak ditemukan elemen meta dengan name twitter:title")
+        return '', ''
+
+def get_digits(series: str, thumbnail_url: str):
+    if series == 'Cospuri':
+        # Extract digits from thumbnail_url
+        match = re.search(r'/0(\d{3})', thumbnail_url)
+        if match:
+            digits = match.group(1)
+            print(f"Kode Digit: {digits}")
+            return digits
+        else:
+            return ''
+    elif series == 'Fellatio Japan':
+        # Extract digits from thumbnail_url
+        match = re.search(r'/(\d+)_', thumbnail_url)
+        if match:
+            digits = match.group(1)
+            print(f"Kode Digit: {digits}")
+            return digits
+        else:
+            return ''
+    else:
+        return ''
+
+def find_image_file(name, directory):
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if file == f'{name}.jpg':
+                return os.path.join(root, file)
+    return None
+
+def extract_number(video_file):
+    # Use a regular expression to find the first group of digits in the video file name
+    match = re.search(r'\d+', video_file)
+    if match:
+        # If a group of digits is found, return it as an integer
+        return int(match.group())
+    else:
+        # If no group of digits is found, return a large number to ensure that this video file is processed last
+        return float('inf')
+
+def get_video_resolution(input_file):
+    command = ['ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'json', input_file]
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode == 0:
+        video_info = json.loads(result.stdout)
+        width = video_info['streams'][0]['width']
+        height = video_info['streams'][0]['height']
+        return (width, height)
+    else:
+        print(f'Error getting video resolution: {result.stderr}')
+        return None
+    
+def convert_videos(height, download_folder):
+    konversi_folder  = '/home/user/app/Hasil Konversi'
+    if not os.path.exists(konversi_folder):
+        os.makedirs(konversi_folder)
+
+    video_extensions = ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv', '.webm', '.mpeg', '.3gp', '.m4v', '.mpg', '.vob', '.ts', '.asf', '.rm', '.swf', '.ogv']
+    for file in os.listdir(download_folder):
+        file_extension = os.path.splitext(file)[1].lower()
+        if file_extension in video_extensions:
+            input_file = os.path.join(download_folder, file)
+            output_file = os.path.join(konversi_folder, file)
+
+            # Get the original width and height of the video using ffprobe
+            resolution = get_video_resolution(input_file)
+            if resolution is not None:
+                width_ori, height_ori = resolution
+
+                # Calculate the width/height for conversion using the formula
+                if (height_ori < width_ori):
+                    width = int((width_ori / height_ori) * height)
+                    if (width_ori / height_ori) * height % 1 != 0:
+                        width += 1
+
+                    # Convert video using ffmpeg
+                    if height == 720:
+                        command = f'ffmpeg -i "{input_file}" -s {width}x{height} -b:v 850k -bufsize 1000k -r 30 -b:a 160k -ar 44100 -ac 2 "{output_file}"'
+                        # command = f'ffmpeg -i "{input_file}" -s {width}x{height} -b:v 1350k -bufsize 1500k -r 30 -b:a 160k -ar 48000 -ac 2 "{output_file}"'
+                    elif height == 480:
+                        command = f'ffmpeg -i "{input_file}" -s {width}x{height} -b:v 600k -bufsize 700k -r 24 -b:a 95k -ar 44100 -ac 2 "{output_file}"'
+                    elif height == 360:
+                        command = f'ffmpeg -i "{input_file}" -s {width}x{height} -b:v 250k -bufsize 300k -r 24 -b:a 50k -ar 44100 -ac 2 "{output_file}"'
+
+                else:
+                    width = height
+                    height = int((height_ori / width_ori) * width)
+                    if (height_ori / width_ori) * width % 1 != 0:
+                        height += 1
+
+                    # Convert video using ffmpeg
+                    if width == 720:
+                        command = f'ffmpeg -i "{input_file}" -s {width}x{height} -b:v 850k -bufsize 1000k -r 30 -b:a 160k -ar 44100 -ac 2 "{output_file}"'
+                        # command = f'ffmpeg -i "{input_file}" -s {width}x{height} -b:v 1350k -bufsize 1500k -r 30 -b:a 160k -ar 48000 -ac 2 "{output_file}"'
+                    elif width == 480:
+                        command = f'ffmpeg -i "{input_file}" -s {width}x{height} -b:v 600k -bufsize 700k -r 24 -b:a 95k -ar 44100 -ac 2 "{output_file}"'
+
+                os.system(command)
+
+    return output_file
+
+def join_video():
+    # Tentukan direktori untuk gambar, video, dan output
+    image_dir = '/home/user/app/Trailer/Thumbnail'
+    if not os.path.exists(image_dir):
+        os.makedirs(image_dir)
+    video_dir = '/home/user/app/Hasil Konversi'
+    if not os.path.exists(video_dir):
+        os.makedirs(video_dir)
+    video_path = '/home/user/app/Trailer/Video'
+    if not os.path.exists(video_path):
+        os.makedirs(video_path)
+
+    # Tentukan jalur ke file audio yang akan digunakan untuk intro
+    audio_file = './sound.wav'
+
+    # Dapatkan daftar file video di direktori video
+    video_files = os.listdir(video_dir)
+
+    # Ulangi daftar file video
+    for video_file in video_files:
+        # Dapatkan nama file video tanpa ekstensi
+        name = os.path.splitext(video_file)[0]
+        # Temukan file gambar yang sesuai
+        image_file = find_image_file(name, image_dir)
+        # Periksa apakah file gambar ada
+        if image_file:
+            output_dir = '/home/user/app/Hasil Join'
+            if not os.path.exists(output_dir):
+                os.makedirs(output_dir)
+            # Tentukan jalur ke file output
+            output_file = os.path.join(output_dir, f'{name}.mp4')
+            # Gunakan ffmpeg untuk membuat video 1 detik dari file gambar dan audio
+            os.system(f"ffmpeg -loop 1 -i {image_file} -i {audio_file} -c:v libx264 -b:v 850k -bufsize 1000k -r 30 -b:a 160k -ar 44100 -ac 2 -t 1 -pix_fmt yuv420p -vf scale=1280:720 -shortest {name}.mp4")
+            # Gunakan ffmpeg untuk menggabungkan intro dan video
+            with open('input.txt', 'w') as f:
+                f.write(f"file '{name}.mp4'\n")
+                f.write(f"file '{os.path.join(video_dir, video_file)}'\n")
+            os.system( f"ffmpeg -f concat -safe 0 -i input.txt -c:v libx264 -b:v 850k -bufsize 1000k -r 30 -b:a 160k -ar 44100 -ac 2 -c:a aac -pix_fmt yuv420p -vf scale=1280:720 {output_file}")
+            print(f"Video intro dan video asli berhasil digabungkan menjadi {output_file}")
+
+            # Dapatkan ukuran output
+            output_file_size = os.path.getsize(output_file)
+
+            # Menampilkan nama file, ukuran file, dan progress
+            print(f"Ukuran file output: {convert_size(output_file_size)}")
+
+            # Hapus file video asli dari direktori video_dir
+            os.remove(os.path.join(video_dir, video_file))
+
+            # Hapus file video intro
+            os.remove(f'{name}.mp4')
+
+    return output_file

paipancon.py

@@ -0,0 +1,91 @@
+import requests
+import re
+
+from other import convert_japanese_to_romaji 
+
+headers = {'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'}
+
+
+def get_info_paipancon(link):
+    # Send a GET request to the link and get the HTML response
+    response = requests.get(link, headers=headers)
+    html = response.text
+
+    # Find the title
+    title_start = html.find('"text-align:center;font-size:x-large;"><a>') + len('"text-align:center;font-size:x-large;"><a>')
+    title_end = html.find('</a>', title_start)
+    title = html[title_start:title_end]
+
+    # Add spaces to the title if necessary
+    title = re.sub(r'([a-z])([A-Z])', r'\1 \2', title)
+    title = re.sub(r'([A-Za-z])-([A-Za-z])', r'\1 - \2', title)
+
+    # # Translate Japanese text to english
+    # if 'GirlsDelta' not in title:
+    #     title = translate_japanese_to_english(title)
+
+    # Capitalize the first letter of each word in the title
+    title = ' '.join([word[0].upper() + word[1:] for word in title.split()])
+
+    # Extract digits from the title
+    digit = re.search(r'(?<=-)\d[\d_]*|^\d[\d_]*', title)
+
+    if digit:
+        digit = digit.group()
+
+    # Remove leading zeros if there are 4 digits
+    if digit and len(digit) == 4 and digit[0] == '0':
+        digit = digit[1:]
+
+    # Find the series
+    series_start = html.find('>系列:') + len('>系列:')
+    series_end = html.find('</a>', series_start)
+    series = html[series_start:series_end]
+
+    # Add spaces to the title if necessary
+    series = re.sub(r'([a-z])([A-Z])', r'\1 \2', series)
+    series = re.sub(r'([A-Za-z])-([A-Za-z])', r'\1 - \2', series)
+
+    # # Translate Japanese text to english
+    # if series == '一本道':
+    #     series = '1pondo'
+    # elif series == 'ラフォーレガール':
+    #     series = 'LaForet Girl'
+    # else:
+    #     series = translate_japanese_to_english(series)
+
+    # Capitalize the first letter of each word in the title
+    series = series.title()
+
+    # Find the actress
+    actress_start = html.find('女優:') + len('女優:')
+    actress_end = html.find('</a>', actress_start)
+    actress = html[actress_start:actress_end]
+
+    # Convert Japanese text to romaji
+    actress = convert_japanese_to_romaji(actress)
+
+    # Add spaces to the title if necessary
+    actress = re.sub(r'([a-z])([A-Z])', r'\1 \2', actress)
+    actress = re.sub(r'([A-Za-z])-([A-Za-z])', r'\1 - \2', actress)
+
+    # Capitalize the first letter of each word in the title
+    actress = actress.title().replace(', ',' & ')
+
+    # Find the server link
+    server_link_start = html.find('https://op1')
+    server_link_end = html.find("' type=", server_link_start)
+    server_link = html[server_link_start:server_link_end]
+
+    # Find the HQ link
+    hq_link_start = html.find('https://fl')
+    hq_link_end = html.find("' type=", hq_link_start)
+    hq_link = html[hq_link_start:hq_link_end]
+
+    # Return the results
+    return title, series, actress, digit, server_link, hq_link
+
+
+
+
+

requirements.txt

@@ -3,4 +3,8 @@ streamlit_option_menu
 pytube
 youtube-dl
 moviepy
-tqdm
+tqdm
+selenium
+pyperclip
+googletrans==4.0.0-rc1
+mega.py

rule34.py

@@ -0,0 +1,81 @@
+from bs4 import BeautifulSoup
+import json
+
+def get_info_rule34(soup: BeautifulSoup):
+    # Mencari judul video di elemen dengan class title_video
+    title = soup.find(class_="title_video")
+    if title:
+        video_title = title.text.strip().replace('/', ' -')
+        idx = video_title.find(']')
+        if idx != -1 and idx + 1 < len(video_title) and video_title[idx + 1].isalpha():
+            video_title = video_title[:idx + 1] + ' ' + video_title[idx + 1:]
+
+        video_title = video_title.title()
+        print(f"Judul Video: {video_title}")
+    else:
+        print("Judul Video tidak ditemukan")
+
+    # Mencari nama artist di elemen dengan class col
+    cols = soup.find_all(class_="col") # Menggunakan find_all untuk mendapatkan semua elemen dengan class col
+    if cols:
+        for col in cols: # Melakukan iterasi untuk setiap elemen col
+            # Mencari elemen dengan class label yang memiliki teks yang cocok dengan regex "Artist.*"
+            label = col.find(class_="label", string="Artist:")
+            if label:
+                # Mencari elemen dengan class item yang merupakan saudara dari label
+                item = label.find_next_sibling(class_="item")
+                if item:
+                    # Mencari elemen dengan class name yang merupakan anak dari item
+                    name = item.find(class_="name")
+                    if name:
+                        artist = name.text.strip()
+                        print(f"Nama Artist: {artist}")
+                        break # Keluar dari loop jika sudah menemukan nama artist
+        else: # Menambahkan else di akhir loop
+            print("Nama Artist tidak ditemukan") # Mencetak pesan jika tidak ada nama artist yang ditemukan
+    else:
+        print("Elemen col tidak ditemukan")
+
+    # Mencari thumbnailUrl di script type="application/ld+json"
+    script = soup.find("script", type="application/ld+json")
+    if script:
+        data = json.loads(script.string)
+        if "thumbnailUrl" in data:
+            thumbnail_url = data['thumbnailUrl']
+            print(f"Thumbnail URL: {thumbnail_url}")
+        else:
+            print("Tidak ditemukan thumbnail URL")
+    else:
+        print("Tidak ditemukan elemen script dengan type application/ld+json")
+
+    # Mencari resolusi yang tersedia
+    resolutions = []
+    for a in soup.find_all('a'):
+        if 'MP4' in a.text and 'p' in a.text:
+            resolutions.append(a.text.split()[1])
+    if resolutions:
+        print("Resolusi yang tersedia: " + ", ".join(resolutions))
+    else:
+        print("Tidak ditemukan resolusi yang tersedia")
+
+    # Mencari kualitas video 720p atau 480p
+    video_quality_elements = soup.find_all("a", class_="tag_item")
+    video_quality_720p = None
+    video_quality_480p = None
+    for element in video_quality_elements:
+        if "720p" in element.text:
+            video_quality_720p = element['href']
+        elif "480p" in element.text:
+            video_quality_480p = element['href']
+
+    if video_quality_720p:
+        print(f"Video kualitas 720p: {video_quality_720p}")
+        video_url = video_quality_720p
+    elif video_quality_480p:
+        print(f"Video kualitas 480p: {video_quality_480p}")
+        video_url = video_quality_480p
+    else:
+        print("Tidak ditemukan video kualitas 720p atau 480p")
+        video_url = None
+
+    return video_title, artist, thumbnail_url, video_url

sankaku.py

@@ -0,0 +1,27 @@
+from bs4 import BeautifulSoup
+
+def get_info_sankaku(soup: BeautifulSoup):
+    # Find the artist information
+    artist_tag = soup.find('li', class_='tag-type-artist')
+    artist = artist_tag.find('a')['href'].split('=')[-1]
+    artist = artist.replace('_', ' ').title()
+
+    # Find the series information
+    series_tag = soup.find('li', class_='tag-type-copyright')
+    series = series_tag.find('a')['href'].split('=')[-1]
+    series = series.replace('_', ' ').title()
+
+    # Find the characters information
+    characters_tags = soup.find_all('li', class_='tag-type-character')
+    characters = []
+    for tag in characters_tags:
+        character = tag.find('a')['href'].split('=')[-1]
+        character = character.replace('_', ' ').title()
+        characters.append(character)
+    characters = ', '.join(characters)
+
+    # Find the link information
+    link_tag = soup.find('source')
+    link = 'https:' + link_tag['src']
+
+    return artist, series, characters, link

trailer.py

@@ -0,0 +1,80 @@
+from bs4 import BeautifulSoup
+import requests
+import os
+import json
+from other import get_video_info, get_digits, download_file, convert_videos, join_video
+
+
+def trailer(url):
+    # Set the path to the thumbnail directory
+    thumbnail_dir = "/home/user/app/Trailer/Thumbnail"
+    if not os.path.exists(thumbnail_dir):
+        os.makedirs(thumbnail_dir)
+
+    # Set the path to the video directory
+    video_dir = "/home/user/app/Hasil Download"
+    response = requests.get(url)
+    soup = BeautifulSoup(response.text, 'html.parser')
+
+    # Dapatkan variabel artis dan seri
+    actress, series, title, video_title = get_video_info(soup)
+
+    # Mencari thumbnailUrl di elemen meta dengan name="twitter:image"
+    thumbnail = soup.find("meta", attrs={"name": "twitter:image"})
+    if thumbnail:
+        thumbnail_url = thumbnail['content']
+        print(f"Thumbnail URL: {thumbnail_url}")
+    else:
+        print("Tidak ditemukan elemen meta dengan name twitter:image")
+
+    if title and thumbnail and thumbnail_url:
+        response = requests.get(thumbnail_url)
+        if response.status_code == 200:
+
+            thumbnail_directory = f"{thumbnail_dir}/{series}"
+            if not os.path.exists(thumbnail_directory):
+                os.makedirs(thumbnail_directory)
+
+            # Dapatkan kode Digit
+            digits = get_digits(series, thumbnail_url)
+            thumbnail_name = f"{series} {digits} - {actress}.jpg"
+
+            with open(f"{thumbnail_directory}/{thumbnail_name}", 'wb') as f:
+                f.write(response.content)
+            print(f"Gambar thumbnail berhasil diunduh dengan nama file {thumbnail_name}")
+        else:
+            print(f"Gagal mengunduh gambar thumbnail dari {thumbnail_url}")
+
+    else:
+        print("Tidak dapat mengunduh gambar thumbnail karena tidak ditemukan thumbnail URL atau judul video")
+
+    # Mencari Video
+    script_tag = soup.find('script', type='application/ld+json')
+    data = json.loads(script_tag.string)
+    selected_video_url = None
+    for item in data['@graph']:
+        if item['@type'] == 'VideoObject':
+            selected_video_url = item['contentURL']
+            break
+
+    # Membuat judul video
+    video_name = f"{series} {digits} - {actress}.mp4"
+
+    if selected_video_url:
+        status = download_file(selected_video_url, video_title, video_dir)
+        print(f"Video trailer berhasil diunduh dengan nama file {video_name}")
+
+        for filename in os.listdir(video_dir):
+            if video_title in filename and filename.endswith('.mp4'):
+                os.rename(os.path.join(video_dir, filename), os.path.join(video_dir, video_name))
+
+    else:
+        print("Tidak dapat mengunduh video karena tidak ditemukan URL atau judul video")
+
+    print("==================================================================================")
+    # Mengkonversi video
+    convert_videos(720)
+    print("==================================================================================")
+    # Menggabungkan video
+    output_file = join_video()
+    print("==================================================================================")