mirror of
https://github.com/Yuvi9587/Kemono-Downloader.git
synced 2025-12-29 16:14:44 +00:00
131 lines
4.5 KiB
Python
131 lines
4.5 KiB
Python
|
|
import os
|
|
import re
|
|
import html
|
|
import time
|
|
import urllib.parse
|
|
import requests
|
|
from datetime import datetime
|
|
import cloudscraper
|
|
|
|
|
|
def extr(txt, begin, end, default=""):
|
|
"""Stripped-down version of 'extract()' to find text between two delimiters."""
|
|
try:
|
|
first = txt.index(begin) + len(begin)
|
|
return txt[first:txt.index(end, first)]
|
|
except (ValueError, IndexError):
|
|
return default
|
|
|
|
def extract_iter(txt, begin, end):
|
|
"""Yields all occurrences of text between two delimiters."""
|
|
try:
|
|
index = txt.index
|
|
lbeg = len(begin)
|
|
lend = len(end)
|
|
pos = 0
|
|
while True:
|
|
first = index(begin, pos) + lbeg
|
|
last = index(end, first)
|
|
pos = last + lend
|
|
yield txt[first:last]
|
|
except (ValueError, IndexError):
|
|
return
|
|
|
|
def nameext_from_url(url):
|
|
"""Extracts filename and extension from a URL."""
|
|
data = {}
|
|
filename = urllib.parse.unquote(url.partition("?")[0].rpartition("/")[2])
|
|
name, _, ext = filename.rpartition(".")
|
|
if name and len(ext) <= 16:
|
|
data["filename"], data["extension"] = name, ext.lower()
|
|
else:
|
|
data["filename"], data["extension"] = filename, ""
|
|
return data
|
|
|
|
def parse_timestamp(ts, default=None):
|
|
"""Creates a datetime object from a Unix timestamp."""
|
|
try:
|
|
return datetime.fromtimestamp(int(ts))
|
|
except (ValueError, TypeError):
|
|
return default
|
|
|
|
|
|
def fetch_erome_data(url, logger):
|
|
"""
|
|
Identifies and extracts all media files from an Erome album URL.
|
|
|
|
Args:
|
|
url (str): The Erome album URL (e.g., https://www.erome.com/a/albumID).
|
|
logger (function): A function to log progress messages.
|
|
|
|
Returns:
|
|
tuple: A tuple containing (album_folder_name, list_of_file_dicts).
|
|
Returns (None, []) if data extraction fails.
|
|
"""
|
|
album_id_match = re.search(r"/a/(\w+)", url)
|
|
if not album_id_match:
|
|
logger(f"Error: The URL '{url}' does not appear to be a valid Erome album link.")
|
|
return None, []
|
|
|
|
album_id = album_id_match.group(1)
|
|
page_url = f"https://www.erome.com/a/{album_id}"
|
|
|
|
session = cloudscraper.create_scraper()
|
|
|
|
try:
|
|
logger(f" Fetching Erome album page: {page_url}")
|
|
for attempt in range(5):
|
|
response = session.get(page_url, timeout=30)
|
|
response.raise_for_status()
|
|
page_content = response.text
|
|
if "<title>Please wait a few moments</title>" in page_content:
|
|
logger(f" Cloudflare check detected. Waiting 5 seconds... (Attempt {attempt + 1}/5)")
|
|
time.sleep(5)
|
|
continue
|
|
break
|
|
else:
|
|
logger(" Error: Could not bypass Cloudflare check after several attempts.")
|
|
return None, []
|
|
|
|
title = html.unescape(extr(page_content, 'property="og:title" content="', '"'))
|
|
user = urllib.parse.unquote(extr(page_content, 'href="https://www.erome.com/', '"', default="unknown_user"))
|
|
|
|
sanitized_title = re.sub(r'[<>:"/\\|?*]', '_', title).strip()
|
|
sanitized_user = re.sub(r'[<>:"/\\|?*]', '_', user).strip()
|
|
|
|
album_folder_name = f"Erome - {sanitized_user} - {sanitized_title} [{album_id}]"
|
|
|
|
urls = []
|
|
media_groups = page_content.split('<div class="media-group"')
|
|
for group in media_groups[1:]:
|
|
video_url = extr(group, '<source src="', '"') or extr(group, 'data-src="', '"')
|
|
if video_url:
|
|
urls.append(video_url)
|
|
|
|
if not urls:
|
|
logger(" Warning: No media URLs found on the album page.")
|
|
return album_folder_name, []
|
|
|
|
logger(f" Found {len(urls)} media files in album '{title}'.")
|
|
|
|
file_list = []
|
|
for i, file_url in enumerate(urls, 1):
|
|
filename_info = nameext_from_url(file_url)
|
|
filename = f"{album_id}_{sanitized_title}_{i:03d}.{filename_info.get('extension', 'mp4')}"
|
|
|
|
file_data = {
|
|
"url": file_url,
|
|
"filename": filename,
|
|
"headers": {"Referer": page_url},
|
|
}
|
|
file_list.append(file_data)
|
|
|
|
return album_folder_name, file_list
|
|
|
|
except requests.exceptions.RequestException as e:
|
|
logger(f" Error fetching Erome page: {e}")
|
|
return None, []
|
|
except Exception as e:
|
|
logger(f" An unexpected error occurred during Erome extraction: {e}")
|
|
return None, [] |