Update watcher.py

watcher.py

@@ -6,7 +6,7 @@ import requests
 from datetime import datetime, timezone
 from bs4 import BeautifulSoup
 
-# ===== Channel.io =====
+# ===== Channel.io 設定 =====
 GET_URL = "https://desk-api.channel.io/desk/channels/200605/groups/519217/messages"
 POST_URL = GET_URL
 
@@ -34,14 +34,13 @@ HEADERS_POST = {
 }
 
 # ===== ssyoutube =====
-DETAIL_URL = "https://ssyoutube.online/yt-video-detail/"
-MERGE_API = "https://ssyoutube.online/wp-admin/admin-ajax.php"
+SSYOUTUBE_URL = "https://ssyoutube.online/yt-video-detail/"
 
 # ===== Utils =====
 def parse_updated_at(value):
     if isinstance(value, (int, float)):
         return datetime.fromtimestamp(value / 1000, tz=timezone.utc)
-    if isinstance(value, str):
+    elif isinstance(value, str):
         return datetime.fromisoformat(value.replace("Z", "+00:00"))
     return None
 
@@ -56,125 +55,143 @@ def extract_youtube_id(text):
             return m.group(1)
     return None
 
-# ===== ssyoutube =====
-def fetch_nonce():
-    res = requests.get(DETAIL_URL, headers={"User-Agent": "Mozilla/5.0"}, timeout=30)
-    res.raise_for_status()
-    soup = BeautifulSoup(res.text, "lxml")
-
-    nonce = soup.select_one('input[name="nonce"]')
-    if nonce:
-        return nonce["value"]
-
-    m = re.search(r'"nonce":"([a-f0-9]+)"', res.text)
-    if m:
-        return m.group(1)
-
-    raise RuntimeError("nonce が取得できません")
-
-def fetch_download_links(youtube_url):
+# ===== ssyoutube HTML解析 & nonce取得 =====
+def fetch_download_links_and_nonce(youtube_url):
     res = requests.post(
-        DETAIL_URL,
+        SSYOUTUBE_URL,
         data={"videoURL": youtube_url},
+        timeout=30,
         headers={
             "User-Agent": "Mozilla/5.0",
-            "Referer": DETAIL_URL,
-        },
-        timeout=30,
+            "Referer": "https://ssyoutube.online/",
+        }
     )
     res.raise_for_status()
 
     soup = BeautifulSoup(res.text, "lxml")
+
+    # ★ wp nonce 取得
+    nonce_el = soup.select_one('meta[name="wp-nonce"], input[name="nonce"]')
+    nonce = nonce_el["content"] if nonce_el and nonce_el.has_attr("content") else nonce_el["value"]
+
     buttons = soup.select("button[data-url]")
+    items = []
 
-    results = []
     for btn in buttons:
         url = btn.get("data-url")
         quality = btn.get("data-quality")
         has_audio = btn.get("data-has-audio")
-        if url:
-            results.append({
-                "url": url,
-                "quality": quality or "audio",
-                "has_audio": has_audio,
-            })
-    return results
 
-def pick_best_streams(items):
-    videos = [i for i in items if i["has_audio"] == "false"]
-    audios = [i for i in items if i["has_audio"] != "false"]
+        if not url:
+            continue
+
+        items.append({
+            "url": url,
+            "quality": quality,
+            "has_audio": has_audio,
+        })
+
+    return items, nonce
+
+def pick_best_video_and_audio(items):
+    video_candidates = []
+    audio_candidates = []
 
-    def vkey(x):
-        m = re.search(r"(\d+)p", x["quality"])
-        return int(m.group(1)) if m else 0
+    for item in items:
+        if item["has_audio"] == "false" and item["quality"]:
+            q = int(re.sub(r"\D", "", item["quality"]))
+            video_candidates.append((q, item))
+        if item["quality"] in (None, "audio"):
+            audio_candidates.append(item)
 
-    best_video = sorted(videos, key=vkey, reverse=True)[0]
-    best_audio = audios[0]
+    if not video_candidates or not audio_candidates:
+        return None, None
+
+    best_video = sorted(video_candidates, key=lambda x: x[0], reverse=True)[0][1]
+    best_audio = audio_candidates[0]
 
     return best_video, best_audio
 
-def start_merge(video, audio, youtube_id, quality, nonce):
-    payload = {
+def merge_video_audio(video, audio, nonce, youtube_id, quality):
+    ajax_url = "https://ssyoutube.online/wp-admin/admin-ajax.php"
+
+    request_data = {
         "id": f"{youtube_id}_{quality}",
         "ttl": 3600000,
         "inputs": [
-            {"url": audio["url"], "ext": "mp4"},
-            {"url": video["url"], "ext": "mp4"},
+            {
+                "url": audio["url"],
+                "ext": "mp4",
+                "chunkDownload": {"type": "header", "size": 52428800, "concurrency": 3}
+            },
+            {
+                "url": video["url"],
+                "ext": "mp4",
+                "chunkDownload": {"type": "header", "size": 52428800, "concurrency": 3}
+            }
         ],
         "output": {
             "ext": "mp4",
             "downloadName": f"{youtube_id}_{quality}.mp4",
+            "chunkUpload": {"size": 104857600, "concurrency": 3}
         },
-        "operation": {"type": "replace_audio_in_video"},
+        "operation": {"type": "replace_audio_in_video"}
     }
 
     files = {
         "action": (None, "process_video_merge"),
         "nonce": (None, nonce),
-        "request_data": (None, json.dumps(payload)),
+        "request_data": (None, json.dumps(request_data)),
     }
 
-    res = requests.post(
-        MERGE_API,
-        files=files,
-        headers={"User-Agent": "Mozilla/5.0"},
-        timeout=30,
-    )
+    res = requests.post(ajax_url, files=files, timeout=30)
     res.raise_for_status()
     return res.json()
 
-def wait_merge_done(monitor_url):
+def wait_for_merge_done(monitor_http):
     while True:
-        res = requests.get(monitor_url, timeout=15)
+        res = requests.get(monitor_http, timeout=15)
         res.raise_for_status()
         data = res.json()
-
         if data["result"]["status"] == "done":
             return data["result"]["output"]["url"]
-
         time.sleep(5)
 
-def build_links(items, merged_url, quality):
+# ===== Build & Send =====
+def build_links(items):
     lines = []
-    for i in items:
-        lines.append(
-            f'<link type="url" value="{i["url"]}"> {i["quality"]}</link>'
-        )
-    lines.append(
-        f'\n<link type="url" value="{merged_url}"> 🔊音声付き {quality}</link>'
-    )
+    for item in items:
+        url = item["url"]
+        quality = item["quality"]
+        has_audio = item["has_audio"]
+
+        audio_label = ""
+        if has_audio == "false":
+            audio_label = "（映像のみ）"
+        elif has_audio == "true":
+            audio_label = "（音声付き）"
+
+        line = f'<link type="url" value="{url}"> {quality} {audio_label}</link>'
+        lines.append(line)
+
     return "\n".join(lines)
 
 def send_to_channel(text):
     payload = {
-        "requestId": f"desk-{int(time.time()*1000)}",
+        "requestId": f"desk-web-{int(time.time() * 1000)}",
         "blocks": [{"type": "text", "value": text}],
+        "buttons": None,
+        "form": None,
+        "webPage": None,
+        "files": None,
+        "customPayload": None
     }
+
     res = requests.post(
         POST_URL,
         headers=HEADERS_POST,
         data=json.dumps(payload),
-        timeout=30,
+        timeout=30
     )
     res.raise_for_status()
 
@@ -184,39 +201,57 @@ def main():
         try:
             res = requests.get(GET_URL, headers=HEADERS_GET, params=PARAMS, timeout=30)
             res.raise_for_status()
+
             messages = res.json().get("messages", [])
+            latest_msg = None
+            latest_time = None
+
+            for msg in messages:
+                plain_text = msg.get("plainText")
+                updated_at = msg.get("updatedAt")
+                if not plain_text or updated_at is None:
+                    continue
 
-            latest = max(
-                (
-                    m for m in messages
-                    if m.get("plainText") and m.get("updatedAt")
-                ),
-                key=lambda m: parse_updated_at(m["updatedAt"]),
-                default=None,
-            )
+                t = parse_updated_at(updated_at)
+                if not t:
+                    continue
 
-            if not latest:
+                if latest_time is None or t > latest_time:
+                    latest_time = t
+                    latest_msg = msg
+
+            if not latest_msg:
                 time.sleep(10)
                 continue
 
-            youtube_id = extract_youtube_id(latest["plainText"])
+            text = latest_msg["plainText"]
+            youtube_id = extract_youtube_id(text)
             if not youtube_id:
                 time.sleep(10)
                 continue
 
             youtube_url = f"https://www.youtube.com/watch?v={youtube_id}"
 
-            items = fetch_download_links(youtube_url)
-            best_video, best_audio = pick_best_streams(items)
+            items, nonce = fetch_download_links_and_nonce(youtube_url)
+            if not items:
+                print("ダウンロードリンクが取得できませんでした")
+                time.sleep(10)
+                continue
+
+            video, audio = pick_best_video_and_audio(items)
+            if not video or not audio:
+                print("動画または音声が取得できませんでした")
+                time.sleep(10)
+                continue
 
-            nonce = fetch_nonce()
-            merge = start_merge(best_video, best_audio, youtube_id, best_video["quality"], nonce)
+            merge_res = merge_video_audio(video, audio, nonce, youtube_id, video["quality"])
+            monitor_http = merge_res["data"]["result"]["monitor"]["http"]
+            final_video_url = wait_for_merge_done(monitor_http)
 
-            monitor = merge["data"]["result"]["monitor"]["http"]
-            merged_url = wait_merge_done(monitor)
+            message_text = build_links(items)
+            message_text += f'\n<link type="url" value="{final_video_url}">🎬 音声付き {video["quality"]}</link>'
 
-            message = build_links(items, merged_url, best_video["quality"])
-            send_to_channel(message)
+            send_to_channel(message_text)
             print("送信完了")
 
         except Exception as e: