diff --git a/py/AAZ音乐.py b/py/AAZ音乐.py deleted file mode 100644 index 9b41a5f..0000000 --- a/py/AAZ音乐.py +++ /dev/null @@ -1,298 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "AAZ音乐" - self.host = "https://www.aaz.cx" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/120.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "new", "type_name": "新歌榜"}, - {"type_id": "top", "type_name": "TOP榜单"}, - {"type_id": "singer", "type_name": "歌手"}, - {"type_id": "playtype", "type_name": "歌单"}, - {"type_id": "album", "type_name": "专辑"}, - {"type_id": "mv", "type_name": "高清MV"}, - ] - self.category_paths = { - "new": "/list/new.html", - "top": "/list/top.html", - "singer": "/singerlist/index/index/index/index.html", - "playtype": "/playtype/index.html", - "album": "/albumlist/index.html", - "mv": "/mvlist/index.html", - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "")).strip() - - def _load_html(self, html): - return self.html(str(html or "").strip() or "") - - def _fetch_html(self, path): - response = self.fetch(self._build_url(path), headers=dict(self.headers), timeout=10, verify=False) - return response.text if getattr(response, "status_code", 0) == 200 else "" - - def _empty_result(self, page=1): - return {"page": int(page), "limit": 0, "total": 0, "list": []} - - def _extract_song_id(self, href): - matched = re.search(r"/m/([^.?#/]+)\.html", str(href or "").strip()) - return matched.group(1) if matched else "" - - def _extract_folder_id(self, href, prefix): - matched = re.search(r"/%s/([^/?#]+)" % re.escape(prefix), str(href or "").strip()) - return matched.group(1) if matched else "" - - def _encode_vod_id(self, href): - raw = str(href or "").strip() - song_id = self._extract_song_id(raw) - if song_id: - return "song:" + song_id - for prefix, label in [("s", "singer"), ("p", "playlist"), ("a", "album"), ("v", "mv")]: - folder_id = self._extract_folder_id(raw, prefix) - if folder_id: - return label + ":" + folder_id - return "" - - def _parse_song_cards(self, html): - root = self._load_html(html) - items = [] - seen = set() - for node in root.xpath("//li"): - href = "".join(node.xpath(".//div[contains(@class,'name')]//a[1]/@href")).strip() - vod_id = self._encode_vod_id(href) - if not vod_id.startswith("song:") or vod_id in seen: - continue - seen.add(vod_id) - has_mv = bool(node.xpath(".//div[contains(@class,'mv')]//a")) - items.append( - { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(node.xpath(".//div[contains(@class,'name')]//a[1]/@title"))), - "vod_pic": "", - "vod_remarks": "高清MV" if has_mv else "", - } - ) - return items - - def _parse_folder_cards(self, html, expected_prefix): - root = self._load_html(html) - items = [] - seen = set() - for node in root.xpath("//li"): - href = "".join(node.xpath(".//div[contains(@class,'name')]//a[1]/@href")).strip() - vod_id = self._encode_vod_id(href) - if not vod_id.startswith(expected_prefix + ":") or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(node.xpath(".//div[contains(@class,'name')]//a[1]/@title"))), - "vod_pic": self._build_url("".join(node.xpath(".//img[1]/@src"))), - "vod_remarks": "", - } - ) - return items - - def _parse_search_cards(self, html): - root = self._load_html(html) - items = [] - seen = set() - for node in root.xpath("//li"): - href = "".join(node.xpath(".//div[contains(@class,'name')]//a[1]/@href")).strip() - vod_id = self._encode_vod_id(href) - if not vod_id or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(node.xpath(".//div[contains(@class,'name')]//a[1]/@title"))), - "vod_pic": self._build_url("".join(node.xpath(".//img[1]/@src"))), - "vod_remarks": "", - } - ) - return items - - def _decode_vod_id(self, vod_id): - raw = str(vod_id or "").strip() - if ":" not in raw: - return "", "" - prefix, value = raw.split(":", 1) - if prefix == "song": - return prefix, "/m/%s.html" % value - if prefix == "singer": - return prefix, "/s/%s" % value - if prefix == "playlist": - return prefix, "/p/%s" % value - if prefix == "album": - return prefix, "/a/%s" % value - if prefix == "mv": - return prefix, "/v/%s" % value - return "", "" - - def _parse_song_detail(self, html, song_id): - title_match = re.search( - r'

(.*?)]+>", " ", title_match.group(1))) if title_match else song_id - singer_match = re.search(r'
]*>([^<]+)
', str(html or "")) - album_match = re.search(r'所属专辑：]*>([^<]+)', str(html or "")) - cover_match = re.search(r'", str(html or "")) - content_match = re.search(r' 0: - items.extend(self._parse_cards(str(blocks[0]))) - if len(blocks) > 1: - items.extend(self._parse_cards(str(blocks[1]))) - return {"list": self._dedupe(items)[:20]} - - def categoryContent(self, tid, pg, filter, extend): - page = max(int(pg), 1) - slug = self._map_type_slug(tid) - html = self._request_html(self._build_category_url(tid, pg, extend or {})) - items = [item for item in self._parse_cards(html) if item["vod_id"].startswith(slug + "/")] - return {"page": page, "limit": 24, "total": page * 24 + len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = max(int(pg), 1) - items = self._parse_cards(self._request_html(self._build_search_url(key, pg))) - if str(quick).lower() == "true": - items = items[:10] - return {"page": page, "limit": 24, "total": page * 24 + len(items), "list": items} - - def detailContent(self, ids): - vod_id = str(ids[0] if isinstance(ids, list) and ids else ids or "").strip().lstrip("/") - if not vod_id: - return {"list": []} - html = self._request_html(f"{self.lang_path}/{vod_id}") - if not html: - return {"list": []} - soup = BeautifulSoup(html, "html.parser") - title_text = self._text(soup.select_one("h1.product-title") or soup.select_one("title")) - info = self._extract_m3u8_items(html) - play_urls = [] - for item in info["items"]: - play_urls.append(f"{item}${self._build_play_id(info['info_id'], item)}") - actor = self._extract_excerpt_text(soup, "主演：").replace(" / ", ",").replace("/", ",") - vod_name = re.sub(r"\s*\([^)]*\)\s*$", "", title_text).strip() - year_match = re.search(r"\((\d{4})\)", title_text) - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": vod_name, - "vod_pic": self._build_url((soup.select_one("header.product-header img.thumb") or {}).get("src", "")), - "type_name": "电视剧" if vod_id.startswith("tv/") else "电影", - "vod_year": year_match.group(1) if year_match else "", - "vod_director": self._extract_excerpt_text(soup, "导演："), - "vod_actor": actor, - "vod_content": self._extract_excerpt_text(soup, "简介："), - "vod_play_from": "PPnix" if play_urls else "", - "vod_play_url": "#".join(play_urls), - } - ] - } - - def playerContent(self, flag, id, vipFlags): - meta = self._parse_play_id(id) - if not meta["info_id"] or not meta["param"]: - return {"parse": 1, "jx": 1, "url": str(id or ""), "header": {}} - encoded = quote(meta["param"]) - return { - "parse": 0, - "jx": 0, - "url": self._build_url(f"/info/m3u8/{meta['info_id']}/{encoded}.m3u8"), - "header": { - "Referer": self.host + self.lang_path + "/", - "Origin": self.host, - "User-Agent": self.headers["User-Agent"], - }, - } diff --git a/py/PPnix.txt b/py/PPnix.txt new file mode 100644 index 0000000..a694ea3 --- /dev/null +++ b/py/PPnix.txt @@ -0,0 +1,15 @@ +// ignore +//@name:PPnix +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:Hy20uWA8+zw1OHVy +//@ek:base64:fsFf8BfRzN9DcMHvWJ5GGYM9GkCzKl0/HGg280qpGeG1wo33A81xd4wqVnra0UTa +//@hash:sha256:047d59d0e2ebd66d20fa657102648fd74052dbf4cde1c361a84ddf21e92bdc77 +//@sig:base64:zwJ3z9SQygQ81TVIDgPYX27LEWHXc2wTXp07fN9SQiKLMV1pvqLZckJHoTjx7QC19BLStDRK7WqsQOS1BAHTAw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/libvio.py b/py/libvio.py deleted file mode 100644 index 6eda869..0000000 --- a/py/libvio.py +++ /dev/null @@ -1,333 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -from urllib.parse import quote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "LibVIO" - self.host = "https://www.libvio.la" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/124.0.0.0 Safari/537.36" - ) - } - self.categories = [ - {"type_name": "最近更新", "type_id": "index"}, - {"type_name": "电影", "type_id": "movie"}, - {"type_name": "电视剧", "type_id": "series"}, - {"type_name": "动漫", "type_id": "anime"}, - {"type_name": "日韩剧", "type_id": "jpandkr"}, - {"type_name": "欧美剧", "type_id": "euandus"}, - ] - self.category_paths = { - "index": "/", - "movie": "/type/1-{pg}.html", - "series": "/type/2-{pg}.html", - "anime": "/type/4-{pg}.html", - "jpandkr": "/type/15-{pg}.html", - "euandus": "/type/16-{pg}.html", - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def _build_url(self, href): - raw = str(href or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return self.host + "/" + raw.lstrip("/") - - def _extract_vod_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"/detail/(\d+)\.html", raw) - if matched: - return matched.group(1) - if re.fullmatch(r"\d+", raw): - return raw - return "" - - def _extract_play_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"/play/([^./]+-\d+-\d+)\.html", raw) - if matched: - return matched.group(1) - if re.fullmatch(r"[^./]+-\d+-\d+", raw): - return raw - return "" - - def _build_detail_request_url(self, vod_id): - return f"{self.host}/detail/{self._extract_vod_id(vod_id)}.html" - - def _build_play_request_url(self, play_id): - return f"{self.host}/play/{self._extract_play_id(play_id)}.html" - - def _parse_list_cards(self, html): - root = self.html(html) - results = [] - if root is None: - return results - - seen = set() - for card in root.xpath("//*[contains(@class,'stui-vodlist__box')]"): - href = ((card.xpath(".//a[@href][1]/@href") or [""])[0]).strip() - vod_id = self._extract_vod_id(href) - title = ((card.xpath(".//a[@title][1]/@title") or [""])[0]).strip() - pic = ( - (card.xpath(".//a[@data-original][1]/@data-original") or [""])[0].strip() - or (card.xpath(".//img[@data-original][1]/@data-original") or [""])[0].strip() - or (card.xpath(".//img[@src][1]/@src") or [""])[0].strip() - ) - remarks = "".join(card.xpath(".//*[contains(@class,'pic-text')][1]//text()")).strip() - if not vod_id or vod_id in seen or not title: - continue - seen.add(vod_id) - results.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return results - - def _request_html(self, path_or_url, expect_xpath=None, referer=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - headers = dict(self.headers) - headers["Referer"] = referer or (self.host + "/") - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _page_result(self, items, pg): - page = int(pg) - return { - "list": items, - "page": page, - "limit": len(items), - "total": page * 30 + len(items), - } - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _extract_detail_field(self, root, label, joiner=""): - if root is None: - return "" - nodes = root.xpath(f'.//span[contains(normalize-space(.), "{label}：")]') - if not nodes: - return "" - values = [] - label_node = nodes[0] - if self._clean_text(label_node.tail): - values.append(self._clean_text(label_node.tail)) - for sibling in label_node.itersiblings(): - if sibling.tag == "span" and "text-muted" in " ".join(sibling.xpath("./@class")): - break - text = self._clean_text("".join(sibling.xpath(".//text()"))) - if text: - values.append(text) - tail = self._clean_text(sibling.tail) - if tail: - values.append(tail) - cleaned = [] - for value in values: - if value and value not in cleaned: - cleaned.append(value) - return joiner.join(cleaned) if joiner else "".join(cleaned) - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - detail_root = (root.xpath("//*[contains(@class,'stui-content__detail')][1]") or [root])[0] - title = ((detail_root.xpath(".//*[contains(@class,'title')][1]//text()") or [""])[0]).strip() - pic = ( - (root.xpath("//*[contains(@class,'stui-content__thumb')]//img/@data-original") or [""])[0].strip() - or (root.xpath("//*[contains(@class,'stui-content__thumb')]//img/@src") or [""])[0].strip() - ) - - episodes = [] - seen = set() - for playlist in root.xpath("//*[contains(@class,'stui-content__playlist')]"): - heading = self._clean_text("".join(playlist.xpath("./preceding-sibling::*[1]//text()"))) - if any(keyword in heading for keyword in ("夸克", "UC", "网盘")): - continue - for anchor in playlist.xpath(".//a[@href]"): - play_id = self._extract_play_id((anchor.xpath("./@href") or [""])[0]) - name = self._clean_text("".join(anchor.xpath(".//text()"))) - if not play_id or not name or play_id in seen: - continue - seen.add(play_id) - episodes.append(f"{name}${play_id}") - - netdisk_groups = self._extract_netdisk_sources(html) - play_from = ["LibVIO"] if episodes else [] - play_url = ["#".join(episodes)] if episodes else [] - for group in netdisk_groups: - play_from.append(group["from"]) - play_url.append(group["urls"]) - - vod = { - "vod_id": vod_id, - "path": self._build_detail_request_url(vod_id), - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_tag": "", - "vod_time": "", - "vod_remarks": "", - "vod_play_from": "$$$".join(play_from), - "vod_play_url": "$$$".join(play_url), - "type_name": self._extract_detail_field(detail_root, "类型"), - "vod_content": self._extract_detail_field(detail_root, "简介"), - "vod_year": self._extract_detail_field(detail_root, "年份"), - "vod_area": self._extract_detail_field(detail_root, "地区"), - "vod_lang": "", - "vod_director": self._extract_detail_field(detail_root, "导演", joiner=","), - "vod_actor": self._extract_detail_field(detail_root, "主演", joiner=","), - } - return {"list": [vod]} - - def _extract_netdisk_sources(self, html): - root = self.html(html) - if root is None: - return [] - - groups = [] - for panel in root.xpath("//*[contains(@class,'netdisk-panel')]"): - heading = self._clean_text("".join(panel.xpath(".//h3[1]//text()"))) - matched = re.search(r"\(([^()]+)\)", heading) - line_name = self._clean_text(matched.group(1) if matched else heading.replace("视频下载", "")) or "网盘资源" - - entries = [] - seen_links = set() - for anchor in panel.xpath(".//a[contains(@class,'netdisk-item')]"): - href = ((anchor.xpath("./@href") or [""])[0]).strip() - url_text = self._clean_text("".join(anchor.xpath(".//*[contains(@class,'netdisk-url')][1]//text()"))) - link = url_text or href - if not link or link in seen_links: - continue - seen_links.add(link) - title = self._clean_text("".join(anchor.xpath(".//*[contains(@class,'netdisk-name')][1]//text()"))) or line_name - entries.append(f"{title}${link}") - - if entries: - groups.append({"from": line_name, "urls": "#".join(entries)}) - return groups - - def homeVideoContent(self): - html = self._request_html("/", expect_xpath="//*[contains(@class,'stui-vodlist__box')]") - return {"list": self._parse_list_cards(html)} - - def categoryContent(self, tid, pg, filter, extend): - path = self.category_paths.get(tid, self.category_paths["movie"]).format(pg=pg) - html = self._request_html(path, expect_xpath="//*[contains(@class,'stui-vodlist__box')]") - return self._page_result(self._parse_list_cards(html), pg) - - def searchContent(self, key, quick, pg="1"): - path = "/search/-------------.html?wd={0}".format(quote(key)) - html = self._request_html(path, expect_xpath="//*[contains(@class,'stui-vodlist__box')]") - return self._page_result(self._parse_list_cards(html), pg) - - def detailContent(self, ids): - vod_id = ids[0] - html = self._request_html( - self._build_detail_request_url(vod_id), - expect_xpath="//*[contains(@class,'stui-content__playlist')]", - ) - return self._parse_detail_page(html, vod_id) - - def _parse_player_config(self, html): - matched = re.search(r"player_[a-z0-9_]+\s*=\s*(\{[\s\S]*?\})\s*;?", html, re.I) - if not matched: - return None - try: - return json.loads(matched.group(1)) - except Exception: - return None - - def _extract_play_api_base(self, body): - matched = re.search(r'src\s*=\s*["\']([^"\']+)["\']', body, re.I) - if not matched: - return "" - return self._build_url(matched.group(1)) - - def _extract_playable_url(self, body): - patterns = [ - r'["\']?urls?["\']?\s*:\s*["\']([^"\']+)["\']', - r'(?:var|let|const)\s+urls?\s*=\s*["\']([^"\']+)["\']', - r'["\']url["\']\s*:\s*["\']([^"\']+\.(?:m3u8|mp4)[^"\']*)["\']', - r'url\s*=\s*["\']([^"\']+\.(?:m3u8|mp4)[^"\']*)["\']', - ] - text = str(body or "") - for pattern in patterns: - matched = re.search(pattern, text, re.I) - if matched: - return self._build_url(matched.group(1).replace("\\/", "/").replace("&", "&").strip()) - return "" - - def _request_player_js(self, source): - return self._request_html(f"/static/player/{source}.js", referer=self.host + "/") - - def playerContent(self, flag, id, vipFlags): - raw_id = str(id or "").strip() - if raw_id.startswith(("https://", "http://")) and any( - token in raw_id for token in ("drive.uc.cn", "pan.quark.cn", "pan.baidu.com", "alipan.com", "aliyundrive.com") - ): - return {"parse": 0, "playUrl": "", "url": raw_id} - - play_page_url = self._build_play_request_url(id) - detail_html = self._request_html(play_page_url, referer=self.host + "/") - config = self._parse_player_config(detail_html) - if not config or config.get("from") in ("kuake", "uc"): - return {"parse": 0, "playUrl": "", "url": ""} - - if config.get("from") == "ty_new1": - api_body = self._request_html(f"/vid/ty4.php?url={config.get('url', '')}", referer=self.host + "/") - final_url = self._extract_playable_url(api_body) - else: - player_js = self._request_player_js(config.get("from", "")) - api_base = self._extract_play_api_base(player_js) - api_url = "{base}{url}&next={next}&id={id}&nid={nid}".format( - base=api_base, - url=config.get("url", ""), - next=config.get("link_next", ""), - id=config.get("id", ""), - nid=config.get("nid", ""), - ) - api_body = self._request_html(api_url, referer=self.host + "/") - final_url = self._extract_playable_url(api_body) - - if not final_url: - return {"parse": 0, "playUrl": "", "url": ""} - - return { - "parse": 0, - "playUrl": "", - "url": final_url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": self.host + "/", - }, - } diff --git a/py/libvio.txt b/py/libvio.txt new file mode 100644 index 0000000..7d0a5a3 --- /dev/null +++ b/py/libvio.txt @@ -0,0 +1,15 @@ +// ignore +//@name:libvio +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:be3JCpYhKm5wIPNB +//@ek:base64:DbVqvFPnUNHlB1YRr22M8PfE2upDDsoHWpuH/J4CQBTL78rAw0yYLGI7cO/ymDNK +//@hash:sha256:77b4a1f0a034ffc26cebb4559c592deb6a25808190db4aed7882ee337faa759b +//@sig:base64:g0uyxoexX75/Ib2TDuSwz/3sN23YEuw2WNNiNUMP2ruXOZKYPb1X6DY5iiwO8TcKnG5rs05KHX6qRgsmjW9FBw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/youknow.py b/py/youknow.py deleted file mode 100644 index 639d50b..0000000 --- a/py/youknow.py +++ /dev/null @@ -1,467 +0,0 @@ -# coding=utf-8 -import base64 -import ast -import json -import re -import sys -from urllib.parse import quote, unquote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "YouKnowTV" - self.host = "https://www.youknow.tv" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/137.0.0.0 Safari/537.36" - ), - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - } - self.categories = [ - {"type_name": "今日更新", "type_id": "index"}, - {"type_name": "剧集", "type_id": "drama"}, - {"type_name": "电影", "type_id": "movie"}, - {"type_name": "综艺", "type_id": "variety"}, - {"type_name": "动漫", "type_id": "anime"}, - {"type_name": "短剧", "type_id": "short"}, - {"type_name": "纪录片", "type_id": "doc"}, - ] - self.category_paths = { - "index": "/label/new/", - "drama": "/show/1--------{pg}---/", - "movie": "/show/2--------{pg}---/", - "variety": "/show/3--------{pg}---/", - "anime": "/show/4--------{pg}---/", - "short": "/show/55--------{pg}---/", - "doc": "/show/5--------{pg}---/", - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def _build_url(self, href): - raw = str(href or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return self.host + "/" + raw.lstrip("/") - - def _extract_vod_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"/d/(\d+)/?$", raw) or re.search(r"/v/(\d+)\.html", raw) - if matched: - return matched.group(1) - if re.fullmatch(r"\d+", raw): - return raw - return "" - - def _extract_play_meta(self, href): - raw = str(href or "").strip() - matched = re.search(r"/p/(\d+)-(\d+)-(\d+)/?$", raw) - if not matched: - return None - return { - "vod_id": matched.group(1), - "source_id": matched.group(2), - "episode_index": int(matched.group(3)), - } - - def _build_detail_request_url(self, vod_id): - return f"{self.host}/d/{self._extract_vod_id(vod_id)}/" - - def _encode_episode_payload(self, payload): - raw = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8") - return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=") - - def _decode_episode_payload(self, value): - text = str(value or "") - padded = text + "=" * (-len(text) % 4) - return json.loads(base64.urlsafe_b64decode(padded.encode("utf-8")).decode("utf-8")) - - def _parse_list_cards(self, html): - root = self.html(html) - if root is None: - return [] - - results = [] - seen = set() - for card in root.xpath("//*[contains(@class,'module-poster-item') or contains(@class,'module-card-item-poster')]"): - href = ((card.xpath("./@href") or [""])[0]).strip() - vod_id = self._extract_vod_id(href) - title = ((card.xpath("./@title") or [""])[0]).strip() or ((card.xpath(".//@alt") or [""])[0]).strip() - pic = ( - (card.xpath("./@data-original") or [""])[0].strip() - or (card.xpath("./@data-src") or [""])[0].strip() - or (card.xpath(".//img/@data-original") or [""])[0].strip() - or (card.xpath(".//img/@data-src") or [""])[0].strip() - or (card.xpath(".//@data-original") or [""])[0].strip() - or (card.xpath(".//@data-src") or [""])[0].strip() - or (card.xpath(".//@src") or [""])[0].strip() - ) - remarks = "".join( - card.xpath(".//*[contains(@class,'module-item-note') or contains(@class,'module-item-text')][1]//text()") - ).strip() - if not vod_id or vod_id in seen or not title: - continue - seen.add(vod_id) - results.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return results - - def _request_html(self, path_or_url, expect_xpath=None, referer=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - headers = dict(self.headers) - headers["Referer"] = referer or (self.host + "/") - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _page_result(self, items, pg): - page = int(pg) - return { - "list": items, - "page": page, - "limit": len(items), - "total": page * 30 + len(items), - } - - def _build_category_path(self, tid, pg): - page = int(pg) - if tid == "index": - return self.category_paths["index"] - type_map = { - "drama": "1", - "movie": "2", - "variety": "3", - "anime": "4", - "short": "55", - "doc": "5", - } - type_id = type_map.get(tid, "2") - if page <= 1: - return f"/show/{type_id}-----------/" - return f"/show/{type_id}--------{page}---/" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _extract_detail_field(self, root, label, joiner=""): - if root is None: - return "" - nodes = root.xpath(f'.//span[normalize-space(.)="{label}："]') - if not nodes: - return "" - label_node = nodes[0] - parent = label_node.getparent() - values = [] - - if self._clean_text(label_node.tail): - values.append(self._clean_text(label_node.tail)) - - if parent is not None: - started = False - for child in parent.iterchildren(): - if child is label_node: - started = True - continue - if not started: - continue - text = self._clean_text("".join(child.xpath(".//text()"))) - if text: - values.append(text) - tail = self._clean_text(child.tail) - if tail: - values.append(tail) - - cleaned = [] - for value in values: - if value and value not in cleaned: - cleaned.append(value) - return joiner.join(cleaned) if joiner else "".join(cleaned) - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - title = ((root.xpath("//*[contains(@class,'module-info-heading')]//h1[1]//text()") or [""])[0]).strip() or ( - (root.xpath("//h1[1]//text()") or [""])[0] - ).strip() - pic = ( - (root.xpath("//*[contains(@class,'module-info-poster')]//img/@data-original") or [""])[0].strip() - or (root.xpath("//*[contains(@class,'module-info-poster')]//img/@src") or [""])[0].strip() - ) - source_names = [self._clean_text(value) for value in root.xpath("//*[@data-dropdown-value]/@data-dropdown-value")] - play_groups = root.xpath("//*[contains(@class,'module-play-list')]") - aligned = {} - - for group_index, group in enumerate(play_groups): - source_name = source_names[group_index] if group_index < len(source_names) else f"线路{group_index + 1}" - for anchor in group.xpath(".//a[@href]"): - href = (anchor.xpath("./@href") or [""])[0] - meta = self._extract_play_meta(href) - if not meta: - continue - key = meta["episode_index"] - if key not in aligned: - aligned[key] = { - "vod_id": meta["vod_id"], - "episode_index": key, - "title": self._clean_text("".join(anchor.xpath(".//text()"))), - "candidates": [], - } - aligned[key]["candidates"].append( - { - "source": source_name, - "source_id": meta["source_id"], - "episode_url": self._build_url(href), - } - ) - - play_urls = [] - for episode_index in sorted(aligned): - record = aligned[episode_index] - payload = self._encode_episode_payload(record) - title_text = record["title"] or f"第{episode_index}集" - play_urls.append(f"{title_text}${payload}") - - vod = { - "vod_id": vod_id, - "path": self._build_detail_request_url(vod_id), - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_tag": "", - "vod_time": "", - "vod_remarks": self._extract_detail_field(root, "备注"), - "vod_play_from": "YouKnowTV", - "vod_play_url": "#".join(play_urls), - "type_name": self._extract_detail_field(root, "类型"), - "vod_content": self._extract_detail_field(root, "简介"), - "vod_year": self._extract_detail_field(root, "年份"), - "vod_area": self._extract_detail_field(root, "地区"), - "vod_lang": self._extract_detail_field(root, "语言"), - "vod_director": self._extract_detail_field(root, "导演", joiner=","), - "vod_actor": self._extract_detail_field(root, "主演", joiner=","), - } - return {"list": [vod]} - - def homeVideoContent(self): - html = self._request_html("/label/new/", expect_xpath="//*[contains(@class,'module-poster-item')]") - return {"list": self._parse_list_cards(html)} - - def categoryContent(self, tid, pg, filter, extend): - path = self._build_category_path(tid, pg) - html = self._request_html( - path, - expect_xpath="//*[contains(@class,'module-poster-item') or contains(@class,'module-card-item-poster')]", - ) - return self._page_result(self._parse_list_cards(html), pg) - - def searchContent(self, key, quick, pg="1"): - path = "/search/-------------.html?wd={0}".format(quote(key)) - html = self._request_html( - path, - expect_xpath="//*[contains(@class,'module-poster-item') or contains(@class,'module-card-item-poster')]", - ) - return self._page_result(self._parse_list_cards(html), pg) - - def detailContent(self, ids): - vod_id = ids[0] - html = self._request_html( - self._build_detail_request_url(vod_id), - expect_xpath="//*[contains(@class,'module-play-list')]", - ) - return self._parse_detail_page(html, vod_id) - - def _safe_unquote(self, value): - try: - return unquote(str(value or "")) - except Exception: - return str(value or "") - - def _base64_decode(self, value): - text = str(value or "").replace("-", "+").replace("_", "/") - text += "=" * (-len(text) % 4) - try: - return base64.b64decode(text.encode("utf-8")).decode("utf-8", errors="ignore") - except Exception: - return "" - - def _normalize_play_url(self, value): - text = str(value or "").strip().replace("\\/", "/").replace("\\u0026", "&") - if text.startswith("//"): - return "https:" + text - if text.startswith("/"): - return self.host + text - return text - - def _is_direct_play_url(self, value): - text = str(value or "").strip().lower() - if not text: - return False - return ( - text.startswith("http://") - or text.startswith("https://") - or text.startswith("//") - or (text.startswith("/") and any(ext in text for ext in (".m3u8", ".mp4", ".flv"))) - ) and any(ext in text for ext in (".m3u8", ".mp4", ".flv")) - - def _parse_player_config(self, html): - text = str(html or "") - matched = re.search(r"player_aaaa\s*=", text, re.I) - if not matched: - return None - object_start = text.find("{", matched.end()) - if object_start < 0: - return None - raw_object = self._extract_balanced_object(text, object_start) - if not raw_object: - return None - return self._parse_object_literal(raw_object) - - def _extract_balanced_object(self, text, start_index): - raw = str(text or "") - if start_index < 0 or start_index >= len(raw) or raw[start_index] != "{": - return "" - - depth = 0 - in_string = False - quote_char = "" - escaped = False - - for index in range(start_index, len(raw)): - char = raw[index] - if in_string: - if escaped: - escaped = False - elif char == "\\": - escaped = True - elif char == quote_char: - in_string = False - continue - - if char in ('"', "'"): - in_string = True - quote_char = char - continue - - if char == "{": - depth += 1 - continue - - if char == "}": - depth -= 1 - if depth == 0: - return raw[start_index : index + 1] - - return "" - - def _parse_object_literal(self, raw): - text = str(raw or "").strip() - if not text: - return None - sanitized = re.sub(r",\s*}", "}", text) - try: - return json.loads(sanitized) - except Exception: - try: - return ast.literal_eval(sanitized) - except Exception: - return None - - def _collect_direct_media_urls(self, html): - text = str(html or "").replace("\\/", "/") - urls = re.findall(r'https?:\/\/[^"\'\s]+?\.(?:m3u8|mp4|flv)(?:\?[^"\'\s]*)?', text, re.I) - proto_less = [ - "https:" + item - for item in re.findall(r'\/\/[^"\'\s]+?\.(?:m3u8|mp4|flv)(?:\?[^"\'\s]*)?', text, re.I) - ] - out = [] - for value in urls + proto_less: - normalized = self._normalize_play_url(value) - if normalized and normalized not in out: - out.append(normalized) - return out - - def _decode_player_url(self, raw_url, encrypt): - mode = str(encrypt or "0") - if mode == "1": - return self._normalize_play_url(self._safe_unquote(raw_url)) - if mode == "2": - seeds = [str(raw_url or ""), self._safe_unquote(raw_url), self._safe_unquote(self._safe_unquote(raw_url))] - candidates = [] - for seed in seeds: - for value in [seed, self._base64_decode(seed)]: - if not value: - continue - candidates.append(value) - candidates.append(self._safe_unquote(value)) - candidates.append(self._safe_unquote(self._safe_unquote(value))) - for value in candidates: - for candidate in [value, self._safe_unquote(value), self._safe_unquote(self._safe_unquote(value))]: - normalized = self._normalize_play_url(candidate) - if self._is_direct_play_url(normalized): - return normalized - return self._normalize_play_url(raw_url) - - def _collect_playable_urls_from_html(self, html): - urls = [] - config = self._parse_player_config(html) - if config and config.get("url"): - decoded = self._decode_player_url(config.get("url", ""), config.get("encrypt", "0")) - if decoded: - urls.append(decoded) - for value in self._collect_direct_media_urls(html): - if value not in urls: - urls.append(value) - root = self.html(html) - iframe = "" - if root is not None: - iframe = ((root.xpath("//*[contains(@class,'embed-responsive-item')][1]/@src")) or [""])[0] - return urls, self._build_url(iframe) if iframe else "" - - def playerContent(self, flag, id, vipFlags): - payload = self._decode_episode_payload(id) - candidates = payload.get("candidates", []) if isinstance(payload, dict) else [] - for candidate in candidates: - episode_url = str(candidate.get("episode_url", "")).strip() - if not episode_url: - continue - page_html = self._request_html(episode_url, referer=self.host + "/") - page_urls, iframe_url = self._collect_playable_urls_from_html(page_html) - if iframe_url: - iframe_html = self._request_html(iframe_url, referer=episode_url) - iframe_urls, _ = self._collect_playable_urls_from_html(iframe_html) - for value in iframe_urls: - if value not in page_urls: - page_urls.append(value) - if page_urls: - return { - "parse": 0, - "playUrl": "", - "url": page_urls[0], - "header": {"User-Agent": self.headers["User-Agent"], "Referer": self.host + "/"}, - } - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/youknow.txt b/py/youknow.txt new file mode 100644 index 0000000..0606608 --- /dev/null +++ b/py/youknow.txt @@ -0,0 +1,15 @@ +// ignore +//@name:youknow +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:kRu3HXrO3a+cEpm/ +//@ek:base64:WcYuvIakGYgriVqIlzIF4dCPYgHTnexrdID8oDLdeaatePv+cs3VPQSoaDMPww7f +//@hash:sha256:84f23d2f3a3b1d68debc2866b9221e54dc396a3b0e8fb0a7452641933ebfa5b7 +//@sig:base64:KNP2Am0FXS2Yrf2AxV4pjpX0caB925DW/B056lZezG3gc3CJMT/k4+o2MPzmyccRqmGBUhPDAbnRTIaUV/chBw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/不太灵.py b/py/不太灵.py deleted file mode 100644 index bbd5e6c..0000000 --- a/py/不太灵.py +++ /dev/null @@ -1,308 +0,0 @@ -# coding=utf-8 -import base64 -import json -import sys -from urllib.parse import unquote, urlencode, urljoin - -import requests - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - DRIVE_ORDER = {"baidu": 1, "quark": 2, "xunlei": 3, "aliyun": 4, "a123": 5, "other": 99} - - def __init__(self): - self.name = "不太灵" - self.api_base = "https://web5.mukaku.com/prod/api/v1/" - self.app_id = "83768d9ad4" - self.identity = "23734adac0301bccdcb107c4aa21f96c" - self.timeout = 10 - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/124.0.0.0 Safari/537.36" - ), - "Referer": self.api_base, - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "电视剧"}, - {"type_id": "3", "type_name": "近日热门"}, - {"type_id": "4", "type_name": "本周热门"}, - {"type_id": "5", "type_name": "本月热门"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def _build_api_url(self, endpoint, params=None): - query = {"app_id": self.app_id, "identity": self.identity} - query.update(params or {}) - return urljoin(self.api_base, endpoint) + "?" + urlencode(query) - - def _parse_payload(self, text): - raw = str(text or "").strip() - if raw.startswith("callback(") and raw.endswith(")"): - raw = raw[9:-1] - return json.loads(raw) if raw else {} - - def _request_api(self, endpoint, params=None): - response = requests.get( - self._build_api_url(endpoint, params), - headers=dict(self.headers), - timeout=self.timeout, - verify=False, - ) - if response.status_code != 200: - return [] if endpoint in {"getVideoList", "getVideoMovieList"} else None - payload = self._parse_payload(response.text) - if not payload or payload.get("success") is not True or payload.get("code") != 200: - return [] if endpoint in {"getVideoList", "getVideoMovieList"} else None - data = payload.get("data") - if endpoint in {"getVideoList", "getVideoMovieList"}: - if isinstance(data, dict) and isinstance(data.get("data"), list): - return data.get("data") - if isinstance(data, dict) and isinstance(data.get("list"), list): - return data.get("list") - return [] - return data - - def _map_filter_values(self, items): - values = [{"n": "不限", "v": "0"}] - for item in items or []: - title = str((item or {}).get("title") or "").strip() - if title: - values.append({"n": title, "v": title}) - return values - - def _build_filters(self, type_data): - if not isinstance(type_data, dict): - return {} - common = [ - {"key": "sc", "name": "影视类型", "value": self._map_filter_values(type_data.get("t1"))}, - {"key": "sd", "name": "制片地区", "value": self._map_filter_values(type_data.get("t2"))}, - {"key": "se", "name": "上映年份", "value": self._map_filter_values(type_data.get("t3"))}, - {"key": "sf", "name": "资源画质", "value": self._map_filter_values(type_data.get("t4"))}, - {"key": "sh", "name": "影视标签", "value": self._map_filter_values(type_data.get("t5"))}, - ] - return { - "1": common, - "2": common + [{"key": "status", "name": "剧集状态", "value": [{"n": "不限", "v": "0"}]}], - } - - def _normalize_video(self, item): - data = item or {} - return { - "vod_id": str(data.get("doub_id") or data.get("id") or ""), - "vod_name": data.get("title") or "未知标题", - "vod_pic": data.get("image") or data.get("epic") or "", - "vod_remarks": data.get("ejs") or data.get("zqxd") or "", - "vod_year": data.get("years") or "", - "vod_content": data.get("abstract") or "", - "vod_actor": data.get("performer") or "", - "vod_director": data.get("director") or "", - "vod_area": data.get("production_area") or "", - } - - def _parse_ext_object(self, ext): - candidates = [ext] - try: - decoded = base64.b64decode(str(ext or "")).decode("utf-8") - if decoded and decoded != ext: - candidates.append(decoded) - except Exception: - pass - for raw in list(candidates): - try: - decoded = unquote(str(raw)) - if decoded != raw: - candidates.append(decoded) - except Exception: - pass - for raw in candidates: - try: - value = json.loads(raw) - if isinstance(value, dict): - return value - except Exception: - continue - return {} - - def _normalize_filter_value(self, value): - text = str(value or "").strip() - return "" if text in {"", "0", "不限", "all"} else text - - def _to01(self, value, fallback=0): - text = str(value if value is not None else fallback).strip().lower() - if text in {"1", "true", "yes", "on"}: - return 1 - if text in {"0", "false", "no", "off", ""}: - return 0 - return fallback - - def _dedupe_by_vod_id(self, items): - result = [] - seen = set() - for item in items or []: - vod_id = str((item or {}).get("doub_id") or (item or {}).get("id") or "") - if not vod_id or vod_id in seen: - continue - seen.add(vod_id) - result.append(item) - return result - - def _paginate_items(self, items, page, limit): - page_num = max(1, int(page)) - size = max(1, int(limit)) - total = len(items) - start = (page_num - 1) * size - return {"page": page_num, "limit": size, "total": total, "list": items[start:start + size]} - - def _build_movie_params(self, tid, pg, ext): - ext_obj = self._parse_ext_object(ext) - return { - "sa": int(tid), - "page": int(pg), - "sc": self._normalize_filter_value(ext_obj.get("sc")), - "sd": self._normalize_filter_value(ext_obj.get("sd")), - "se": self._normalize_filter_value(ext_obj.get("se")), - "sf": self._normalize_filter_value(ext_obj.get("sf")), - "sh": self._normalize_filter_value(ext_obj.get("sh")), - "sg": self._normalize_filter_value(ext_obj.get("sg")) or "1", - "iswp": self._to01(ext_obj.get("iswp"), 0), - } - - def _normalize_drive_key(self, value): - text = str(value or "").strip().lower() - if text in {"alipan", "aliyun", "aliyundrive", "ali", "阿里"}: - return "aliyun" - if "quark" in text or "夸克" in text: - return "quark" - if "baidu" in text or "百度" in text: - return "baidu" - if "xunlei" in text or "迅雷" in text: - return "xunlei" - if "123" in text: - return "a123" - return "other" - - def _detect_drive_type_by_url(self, url): - text = str(url or "").lower() - if "pan.quark.cn" in text: - return "quark" - if "pan.baidu.com" in text: - return "baidu" - if "pan.xunlei.com" in text: - return "xunlei" - if "alipan.com" in text or "aliyundrive.com" in text: - return "aliyun" - if "123865.com" in text or "123684.com" in text or "123pan.com" in text: - return "a123" - return "other" - - def _is_supported_pan_url(self, url): - text = str(url or "").strip().lower() - return any( - token in text - for token in [ - "pan.quark.cn", - "pan.baidu.com", - "pan.xunlei.com", - "alipan.com", - "aliyundrive.com", - "123865.com", - "123684.com", - "123pan.com", - "drive.uc.cn", - ] - ) - - def _extract_pan_sources(self, detail): - groups = (detail or {}).get("movies_online_seed") - if not isinstance(groups, dict): - return "", "" - seen = set() - counters = {} - entries = [] - for group_name, items in groups.items(): - for item in items or []: - link = str((item or {}).get("link") or "").strip() - if not link or link in seen: - continue - seen.add(link) - kind = self._detect_drive_type_by_url(link) - if kind == "other": - kind = self._normalize_drive_key(group_name) - counters[kind] = counters.get(kind, 0) + 1 - line_name = f"{kind}#{counters[kind]}" - entries.append((line_name, link)) - entries.sort( - key=lambda pair: ( - self.DRIVE_ORDER.get(pair[0].split("#")[0], 999), - int(pair[0].split("#")[1]), - pair[0], - ) - ) - return "$$$".join(name for name, _ in entries), "$$$".join(f"{name}${url}" for name, url in entries) - - def homeContent(self, filter): - return {"class": self.classes, "filters": self._build_filters(self._request_api("getVideoTypeList", {}))} - - def homeVideoContent(self): - items = self._request_api("getVideoList", {"sc": "3", "limit": 20}) or [] - return {"list": [self._normalize_video(item) for item in items]} - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - if str(tid) in {"1", "2"}: - items = self._dedupe_by_vod_id( - self._request_api("getVideoMovieList", self._build_movie_params(tid, page, extend)) or [] - ) - return { - "page": page, - "limit": len(items) or 20, - "total": page * 20 + len(items), - "list": [self._normalize_video(item) for item in items], - } - items = self._dedupe_by_vod_id(self._request_api("getVideoList", {"sc": str(tid), "page": 1, "limit": 300}) or []) - paged = self._paginate_items(items, page, 20) - paged["list"] = [self._normalize_video(item) for item in paged["list"]] - return paged - - def searchContent(self, key, quick, pg="1"): - keyword = str(key or "").strip() - page = int(pg) - if not keyword: - return {"page": page, "total": 0, "list": []} - items = self._request_api("getVideoList", {"sb": keyword, "page": 1, "limit": 300}) or [] - matched = [item for item in items if keyword.lower() in str((item or {}).get("title") or "").lower()] - paged = self._paginate_items(self._dedupe_by_vod_id(matched), page, 20) - paged["list"] = [self._normalize_video(item) for item in paged["list"]] - return paged - - def detailContent(self, ids): - vod_id = str(ids[0] if isinstance(ids, list) and ids else ids or "").strip() - if not vod_id: - return {"list": []} - data = self._request_api("getVideoDetail", {"id": vod_id}) - if not isinstance(data, dict): - return {"list": []} - vod = self._normalize_video(data) - play_from, play_url = self._extract_pan_sources(data) - vod["vod_play_from"] = play_from - vod["vod_play_url"] = play_url - return {"list": [vod]} - - def playerContent(self, flag, id, vipFlags): - raw = str(id or "").strip() - url = raw[7:] if raw.startswith("push://") else raw - if self._is_supported_pan_url(url): - return {"parse": 0, "playUrl": "", "url": url} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/不太灵.txt b/py/不太灵.txt new file mode 100644 index 0000000..0639c6f --- /dev/null +++ b/py/不太灵.txt @@ -0,0 +1,15 @@ +// ignore +//@name:不太灵 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:flPipJoVSDlAmOUe +//@ek:base64:5mCpHpcCeTLWjrrs+4xQ8Y8kFP3GcA0x+Of+I+Pm4S9IKtfsAbLuWv5p9Bx5fnNF +//@hash:sha256:9c66e0cf4a84f0cf708f1e5baccf2f6674aabdf5c05438dc68bac6407088a65e +//@sig:base64:7ktQRFQqOv3uq1yEYc83khiw3LEQaiv/HI4cm7sW5K423iN/tKJOLCGElMf8D3DujN4r4WLNAvhA+p/jvbJlAw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/世纪音乐.py b/py/世纪音乐.py deleted file mode 100644 index 11ae2fc..0000000 --- a/py/世纪音乐.py +++ /dev/null @@ -1,376 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "世纪音乐" - self.host = "https://www.4c44.com" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/120.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "home", "type_name": "首页推荐"}, - {"type_id": "rank_list", "type_name": "排行榜"}, - {"type_id": "playlist", "type_name": "歌单"}, - {"type_id": "singer", "type_name": "歌手"}, - {"type_id": "mv", "type_name": "MV"}, - ] - self.rank_list = [ - ("rise", "音乐飙升榜"), - ("new", "新歌排行榜"), - ("top", "Top热歌榜"), - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "")).strip() - - def _load_html(self, html): - return self.html(str(html or "").strip() or "") - - def _fetch_html(self, path): - response = self.fetch(self._build_url(path), headers=dict(self.headers), timeout=10, verify=False) - return response.text if getattr(response, "status_code", 0) == 200 else "" - - def _encode_vod_id(self, href): - href = str(href or "") - if "/mp3/" in href: - return "song:" + self._extract_site_id(href, "mp3") - if "/mp4/" in href: - return "mv:" + self._extract_site_id(href, "mp4") - if "/playlist/" in href: - return "playlist:" + self._extract_site_id(href, "playlist") - if "/singer/" in href: - return "singer:" + self._extract_site_id(href, "singer") - return "" - - def _extract_site_id(self, href, prefix): - text = str(href or "") - marker = f"/{prefix}/" - if marker not in text: - return "" - return text.split(marker, 1)[1].split(".html", 1)[0].split("/", 1)[0] - - def _build_filters(self): - return { - "singer": [ - { - "key": "sex", - "name": "性别", - "value": [ - {"n": "女歌手", "v": "girl"}, - {"n": "男歌手", "v": "male"}, - {"n": "乐队组合", "v": "band"}, - ], - }, - { - "key": "area", - "name": "地区", - "value": [ - {"n": "华语", "v": "huayu"}, - {"n": "欧美", "v": "oumei"}, - {"n": "韩国", "v": "hanguo"}, - {"n": "日本", "v": "riben"}, - ], - }, - { - "key": "char", - "name": "字母", - "value": [{"n": "全部", "v": "index"}], - }, - ], - "mv": [ - { - "key": "area", - "name": "地区", - "value": [{"n": "全部地区", "v": "index"}], - }, - { - "key": "type", - "name": "类型", - "value": [{"n": "全部类型", "v": "index"}], - }, - { - "key": "sort", - "name": "排序", - "value": [ - {"n": "最新", "v": "new"}, - {"n": "最热", "v": "hot"}, - {"n": "上升最快", "v": "rise"}, - ], - }, - ], - "playlist": [ - { - "key": "lang", - "name": "语种", - "value": [{"n": "全部语种", "v": "index"}], - }, - { - "key": "style", - "name": "风格", - "value": [ - {"n": "流行", "v": "liuxing"}, - {"n": "摇滚", "v": "yaogun"}, - ], - }, - ], - } - - def _parse_home_items(self, html): - root = self._load_html(html) - items = [] - for node in root.xpath("//*[@id='datalist']//li | //*[contains(@class,'video_list')]//li"): - href = "".join(node.xpath(".//a[1]/@href")).strip() - vod_id = self._encode_vod_id(href) - if not vod_id: - continue - name = self._clean_text("".join(node.xpath(".//div[contains(@class,'name')]//a[1]//text()"))) - singer = self._clean_text("".join(node.xpath(".//*[contains(@class,'singer')][1]//text()"))) - pic = self._build_url("".join(node.xpath(".//img[1]/@src"))) - if vod_id.startswith("song:") and singer: - name = f"{singer} - {name}" - items.append( - { - "vod_id": vod_id, - "vod_name": name, - "vod_pic": pic, - "vod_remarks": "", - } - ) - return items - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def _decode_vod_id(self, vod_id): - raw = str(vod_id or "").strip() - if ":" not in raw: - return "", "" - prefix, value = raw.split(":", 1) - if prefix == "rank": - return prefix, f"/list/{value}.html" - if prefix == "song": - return prefix, f"/mp3/{value}.html" - if prefix == "mv": - return prefix, f"/mp4/{value}.html" - if prefix == "playlist": - return prefix, f"/playlist/{value}.html" - if prefix == "singer": - return prefix, f"/singer/{value}.html" - return "", "" - - def _encode_play_id(self, kind, value): - if kind == "music": - return f"music:{value}" - if kind == "vplay": - return f"vplay:{value}:1080" - return "" - - def _decode_play_id(self, play_id): - raw = str(play_id or "").strip() - if raw.startswith("music:"): - return "music", raw.split(":", 1)[1], "0" - if raw.startswith("vplay:"): - _, mv_id, quality = raw.split(":", 2) - return "vplay", mv_id, quality - return "", "", "" - - def _parse_list_cards(self, html, expected_prefixes): - root = self._load_html(html) - items = [] - seen = set() - for node in root.xpath("//li"): - href = "".join(node.xpath(".//a[1]/@href")).strip() - vod_id = self._encode_vod_id(href) - if not vod_id or vod_id in seen: - continue - if expected_prefixes and not any(vod_id.startswith(prefix) for prefix in expected_prefixes): - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": self._clean_text( - "".join(node.xpath(".//div[contains(@class,'name')]//text()")) - or "".join(node.xpath(".//a[1]//text()")) - ), - "vod_pic": self._build_url("".join(node.xpath(".//img[1]/@src"))), - "vod_remarks": "", - } - ) - return items - - def _build_episode_rows(self, html): - root = self._load_html(html) - rows = [] - for node in root.xpath("//*[contains(@class,'play_list')]//li"): - href = "".join(node.xpath(".//a[1]/@href")).strip() - song_id = self._extract_site_id(href, "mp3") - if not song_id: - continue - rows.append( - self._clean_text("".join(node.xpath(".//a[1]//text()"))) - + "$" - + self._encode_play_id("music", song_id) - ) - return rows - - def homeContent(self, filter): - items = self._parse_home_items(self._fetch_html("/")) - return {"class": list(self.classes), "filters": self._build_filters(), "list": items} - - def homeVideoContent(self): - return {"list": self.homeContent(False).get("list", [])} - - def categoryContent(self, tid, pg, filter, extend): - if tid == "home": - return self._page_result(self.homeContent(False).get("list", []), 1) - if tid == "rank_list": - return self._page_result( - [ - { - "vod_id": f"rank:{rank_id}", - "vod_name": title, - "vod_pic": "", - "vod_remarks": "排行榜", - } - for rank_id, title in self.rank_list - ], - pg, - ) - if tid == "playlist": - return self._page_result( - self._parse_list_cards(self._fetch_html("/playlists/index.html"), ["playlist:"]), - pg, - ) - if tid == "singer": - return self._page_result( - self._parse_list_cards(self._fetch_html("/singerlist/huayu/girl/index.html"), ["singer:"]), - pg, - ) - if tid == "mv": - return self._page_result( - self._parse_list_cards(self._fetch_html("/mvlist/index/index/new.html"), ["mv:"]), - pg, - ) - return {"page": 1, "limit": 0, "total": 0, "list": []} - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - if not keyword: - return {"page": 1, "limit": 0, "total": 0, "list": []} - items = self._parse_list_cards( - self._fetch_html(f"/so.php?wd={keyword}&page={pg}"), - ["song:", "mv:", "playlist:", "singer:"], - ) - return self._page_result(items, pg) - - def detailContent(self, ids): - vod_id = str((ids or [""])[0] or "").strip() - kind, path = self._decode_vod_id(vod_id) - if not path: - return {"list": []} - html = self._fetch_html(path) - root = self._load_html(html) - title = self._clean_text("".join(root.xpath("//h1[1]//text()"))) - pic = self._build_url("".join(root.xpath("(//img[1]/@src)[1]"))) - if kind == "rank": - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": title or "排行榜", - "vod_pic": pic, - "vod_remarks": "", - "vod_content": "", - "vod_play_from": self.name, - "vod_play_url": "#".join(self._build_episode_rows(html)), - } - ] - } - if kind == "song": - singer = self._clean_text("".join(root.xpath("//*[contains(@class,'play_singer')]//a[1]//text()"))) - display = f"{singer} - {title}" if singer else title - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": pic, - "vod_remarks": "", - "vod_content": "", - "vod_actor": singer, - "vod_play_from": self.name, - "vod_play_url": display + "$" + self._encode_play_id("music", vod_id.split(":", 1)[1]), - } - ] - } - if kind == "mv": - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": pic, - "vod_remarks": "", - "vod_content": "", - "vod_play_from": self.name, - "vod_play_url": title + "$" + self._encode_play_id("vplay", vod_id.split(":", 1)[1]), - } - ] - } - if kind in ("playlist", "singer"): - content = self._clean_text("".join(root.xpath("//*[contains(@class,'info')]//p[1]//text()"))) - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": pic, - "vod_remarks": "", - "vod_content": content, - "vod_play_from": self.name, - "vod_play_url": "#".join(self._build_episode_rows(html)), - } - ] - } - return {"list": []} - - def playerContent(self, flag, id, vipFlags): - kind, value, quality = self._decode_play_id(id) - if kind == "music": - url = f"{self.host}/data/down.php?ac=music&id={value}" - elif kind == "vplay": - url = f"{self.host}/data/down.php?ac=vplay&id={value}&q={quality}" - else: - url = "" - return { - "parse": 0, - "url": url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": self.host + "/", - }, - } diff --git a/py/世纪音乐.txt b/py/世纪音乐.txt new file mode 100644 index 0000000..f95098d --- /dev/null +++ b/py/世纪音乐.txt @@ -0,0 +1,15 @@ +// ignore +//@name:世纪音乐 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:jp/vDADzfI+2pmx/ +//@ek:base64:VT4MEo2hafoWaUmQwp6XEbH8LXQ8rq/ncM4XQ6A3fuIBV89AflFCLAd2wGQ98o1A +//@hash:sha256:3ff63ccfe949baef6b47707542cb9b6b19873a7f4784aad07f4b4c3020e4012c +//@sig:base64:0egnCdgdjuupB1itLSx/+gFgIz2jYIDlC4y/AflEbRU1A9iKBbSsZws/q+m450Py5qfWvFfgsool62eYjaMLAQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/两个BT.py b/py/两个BT.py deleted file mode 100644 index ca1f1e5..0000000 --- a/py/两个BT.py +++ /dev/null @@ -1,573 +0,0 @@ -# coding=utf-8 -import base64 -import hashlib -import json -import os -import re -import subprocess -import sys -import tempfile -from urllib.parse import quote, urlencode, urljoin - -from lxml import html as lxml_html - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "两个BT" - self.host = "https://www.bttwoo.com" - self._wasm_asset_cache = {} - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/124.0.0.0 Safari/537.36" - ), - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "zgjun", "type_name": "国产剧"}, - {"type_id": "meiju", "type_name": "美剧"}, - {"type_id": "jpsrtv", "type_name": "日韩剧"}, - {"type_id": "movie_bt_tags/xiju", "type_name": "喜剧"}, - {"type_id": "movie_bt_tags/aiqing", "type_name": "爱情"}, - {"type_id": "movie_bt_tags/adt", "type_name": "冒险"}, - {"type_id": "movie_bt_tags/at", "type_name": "动作"}, - {"type_id": "movie_bt_tags/donghua", "type_name": "动画"}, - {"type_id": "movie_bt_tags/qihuan", "type_name": "奇幻"}, - {"type_id": "movie_bt_tags/xuanni", "type_name": "悬疑"}, - {"type_id": "movie_bt_tags/kehuan", "type_name": "科幻"}, - {"type_id": "movie_bt_tags/juqing", "type_name": "剧情"}, - {"type_id": "movie_bt_tags/kongbu", "type_name": "恐怖"}, - {"type_id": "gf", "type_name": "高分电影"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - return {"list": self._extract_cards(self._request_html(self.host))} - - def categoryContent(self, tid, pg, filter, extend): - page = max(1, self._to_int(pg, 1)) - items = self._extract_cards(self._request_html(self._build_category_url(tid, page))) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = max(1, self._to_int(pg, 1)) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "limit": 0, "total": 0, "list": []} - url = self.host + f"/search?q={quote(keyword)}" - if page > 1: - url += f"&page={page}" - items = self._extract_cards(self._request_html(url), keyword=keyword) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def detailContent(self, ids): - vod_id = self._normalize_vod_id(ids[0] if isinstance(ids, list) and ids else ids) - if not vod_id: - return {"list": []} - html = self._request_html(self._build_detail_url(vod_id)) - detail = self._parse_detail(html, vod_id) - return {"list": [detail]} if detail else {"list": []} - - def playerContent(self, flag, id, vipFlags): - play_id = str(id or "").strip() - if self._is_media_url(play_id): - return self._build_player_result(play_id, self.host + "/") - - meta = self._decode_play_id(play_id) - pid = meta.get("pid") or play_id - play_path = self._extract_play_path(pid) - if str(pid or "").startswith(("http://", "https://")): - play_page_url = str(pid) - elif play_path: - play_page_url = self._abs_url(play_path) - else: - play_page_url = self.host + f"/v_play/{pid}.html" - html = self._request_html(play_page_url, referer=self.host + "/") - media_url = self._extract_media_url(html) - if media_url: - return self._build_player_result(media_url, play_page_url) - - iframe_url = self._extract_iframe_url(html) - if iframe_url: - iframe_html = self._request_html(iframe_url, referer=play_page_url) - iframe_media_url = self._extract_media_url(iframe_html) - if iframe_media_url: - return self._build_player_result(iframe_media_url, iframe_url) - - if play_path: - self._cache_wasm_assets(html) - dataid = self._extract_play_dataid(html, play_page_url) - secret_key = play_path.rsplit("/", 1)[-1] - userlink = self._extract_userlink(html) or "0" - api_url = self._build_wasm_play_api_url(dataid, secret_key, "1080", userlink) - api_data = self._request_json(api_url, referer=play_page_url) - media_url = self._extract_media_from_play_api(api_data) - if media_url: - return self._build_player_result(media_url, play_page_url) - - return self._build_parse_result(play_page_url, play_page_url) - - def _request_html(self, url, referer=None): - headers = dict(self.headers) - headers["Referer"] = referer or self.headers["Referer"] - try: - response = self.fetch(url, headers=headers, timeout=10, verify=False) - except Exception: - return "" - if response.status_code != 200: - return "" - return str(response.text or "") - - def _build_category_url(self, tid, page): - path = str(tid or "").strip().lstrip("/") - filters = { - "zgjun": {"classify": "2", "tvclasses": "20"}, - "meiju": {"classify": "2", "tvclasses": "21"}, - "jpsrtv": {"classify": "2", "tvclasses": "22"}, - "movie_bt_tags/xiju": {"classify": "1", "types": "5"}, - "movie_bt_tags/aiqing": {"classify": "1", "types": "6"}, - "movie_bt_tags/adt": {"classify": "1", "types": "18"}, - "movie_bt_tags/at": {"classify": "1", "types": "10"}, - "movie_bt_tags/donghua": {"classify": "1", "types": "11"}, - "movie_bt_tags/qihuan": {"classify": "1", "types": "12"}, - "movie_bt_tags/xuanni": {"classify": "1", "types": "2"}, - "movie_bt_tags/kehuan": {"classify": "1", "types": "14"}, - "movie_bt_tags/juqing": {"classify": "1", "types": "1"}, - "movie_bt_tags/kongbu": {"classify": "1", "types": "3"}, - "gf": {"classify": "1", "sort_by": "score", "order": "desc"}, - }.get(path) - if filters: - params = dict(filters) - if page > 1: - params["page"] = str(page) - return self.host + "/filter?" + urlencode(params) - url = self.host + "/" + path - if page > 1: - url += f"?page={page}" - return url - - def _extract_cards(self, html, keyword=None): - root = self._parse_html(html) - if root is None: - return [] - results = [] - seen = set() - nodes = root.xpath( - "//*[contains(concat(' ', normalize-space(@class), ' '), ' movie-card ')]" - "|//li[.//a[contains(@href,'/movie/')]]" - ) - for node in nodes: - href = ( - self._first_attr(node, ".//a[contains(@href,'/play/')][1]", "href") - or self._first_attr(node, ".//a[contains(@href,'/movie/')][1]", "href") - ) - vod_id = self._extract_card_id(href) - title = ( - self._first_text(node, ".//h3//a[1]") - or self._first_text(node, ".//h3[1]") - or self._clean_text(self._first_attr(node, ".//a[@title][1]", "title")) - or self._clean_text(self._first_attr(node, ".//img[@alt][1]", "alt")) - or self._first_text(node, ".//*[contains(@class,'title')][1]") - or self._first_text(node, ".//*[contains(@class,'name')][1]") - ) - if not vod_id or not title or vod_id in seen: - continue - if keyword and not self._is_relevant_search_result(title, keyword): - continue - pic = ( - self._first_attr(node, ".//img[@data-original][1]", "data-original") - or self._first_attr(node, ".//img[@data-src][1]", "data-src") - or self._first_attr(node, ".//img[@src][1]", "src") - ) - remarks = ( - self._first_text(node, ".//*[contains(@class,'rating')][1]") - or self._first_text(node, ".//*[contains(@class,'status')][1]") - or self._first_text(node, ".//span[contains(text(),'集')][1]") - or self._first_text(node, ".//span[contains(text(),'HD')][1]") - or self._first_text(node, ".//span[contains(text(),'4k')][1]") - ) - seen.add(vod_id) - results.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._abs_url(pic), - "vod_remarks": remarks, - } - ) - return results - - def _is_relevant_search_result(self, title, keyword): - title_text = self._clean_text(title).lower() - keyword_text = self._clean_text(keyword).lower() - if not title_text or not keyword_text: - return False - if keyword_text in title_text: - return True - if len(keyword_text) <= 2: - return False - key_chars = set(keyword_text.replace(" ", "")) - title_chars = set(title_text.replace(" ", "")) - if not key_chars: - return False - return len(key_chars & title_chars) / float(len(key_chars)) >= 0.6 - - def _extract_vod_id(self, href): - matched = re.search(r"/movie/(\d+)\.html", str(href or "").strip()) - return matched.group(1) if matched else "" - - def _extract_play_path(self, href): - raw = str(href or "").strip() - if "/play/" not in raw: - return "" - path = raw[raw.find("/play/") :] - return path.split("?", 1)[0].split("#", 1)[0] - - def _extract_card_id(self, href): - return self._extract_play_path(href) or self._extract_vod_id(href) - - def _extract_play_pid(self, href): - matched = re.search(r"/v_play/([^.]+)\.html", str(href or "").strip()) - return matched.group(1) if matched else "" - - def _normalize_vod_id(self, value): - raw = str(value or "").strip() - return self._extract_play_path(raw) or raw - - def _build_detail_url(self, vod_id): - raw = str(vod_id or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - play_path = self._extract_play_path(raw) - if play_path: - return self._abs_url(play_path) - if raw.startswith("/movie/"): - return self._abs_url(raw) - return self.host + f"/movie/{raw}.html" - - def _parse_detail(self, html, vod_id): - root = self._parse_html(html) - if root is None: - return None - - vod_name = ( - self._first_text(root, "//*[contains(@class,'movie-poster')]//h1[1]") - or self._first_text(root, "//h1[1]") - or self._first_text(root, "//h2[1]") - or self._extract_title_text(html) - ) - vod_pic = ( - self._first_attr(root, "//meta[@property='og:image'][1]", "content") - or self._first_attr(root, "//*[contains(@class,'movie-poster')]//img[1]", "src") - or self._first_attr(root, "//img[contains(@class,'poster')][1]", "src") - or self._first_attr(root, "//*[contains(@class,'poster')]//img[1]", "src") - or self._first_attr(root, "//img[1]", "src") - ) - vod_content = ( - self._first_attr(root, "//meta[@name='description'][1]", "content") - or self._first_text(root, "//*[contains(text(),'剧情简介')]/following::p[1]") - or self._first_text(root, "//*[contains(@class,'intro')][1]") - or self._first_text(root, "//*[contains(@class,'description')][1]") - or self._first_text(root, "//*[contains(@class,'desc')][1]") - ) - vod_actor = self._extract_labeled_value(root, "主演") or self._extract_meta_text(root, "主演") - vod_director = self._extract_labeled_value(root, "导演") or self._extract_meta_text(root, "导演") - - episodes = [] - seen = set() - episode_nodes = root.xpath( - "//*[@x-data[contains(.,'episodeManager')]]//a[contains(@href,'/play/')]" - "|//*[contains(@class,'episode-link') and contains(@href,'/play/')]" - "|//a[contains(@href,'/v_play/')]" - ) - for index, node in enumerate(episode_nodes): - href = str(node.get("href") or "").strip() - pid = self._extract_play_path(href) or self._extract_play_pid(href) - name = self._clean_text(node.text_content()) or self._clean_text(node.get("data-episode")) or f"第{index + 1}集" - if not pid or pid in seen: - continue - seen.add(pid) - episodes.append(f"{name}${self._encode_play_id(pid, vod_id, name)}") - - if not episodes: - return None - - return { - "vod_id": vod_id, - "vod_name": vod_name or "未知标题", - "vod_pic": self._abs_url(vod_pic), - "vod_content": vod_content, - "vod_actor": vod_actor, - "vod_director": vod_director, - "vod_play_from": "两个BT", - "vod_play_url": "#".join(episodes), - } - - def _encode_play_id(self, pid, sid, name): - raw = json.dumps( - {"pid": str(pid or ""), "sid": str(sid or ""), "name": str(name or "")}, - ensure_ascii=False, - separators=(",", ":"), - ) - return base64.b64encode(raw.encode("utf-8")).decode("utf-8") - - def _decode_play_id(self, value): - try: - raw = base64.b64decode(str(value or "").encode("utf-8")).decode("utf-8") - data = json.loads(raw) - except Exception: - return {"pid": "", "sid": "", "name": ""} - return { - "pid": str(data.get("pid") or ""), - "sid": str(data.get("sid") or ""), - "name": str(data.get("name") or ""), - } - - def _extract_title_text(self, html): - matched = re.search(r"(.*?)", str(html or ""), re.I | re.S) - return self._clean_text(matched.group(1)) if matched else "" - - def _extract_meta_text(self, root, label): - text = self._first_text(root, f"//*[contains(text(),'{label}')][1]") - return re.sub(rf"^{label}[:：]?", "", text).strip() - - def _extract_labeled_value(self, root, label): - if root is None: - return "" - for node in root.xpath( - f"//*[normalize-space(text())='{label}' or contains(text(),'{label}：') or contains(text(),'{label}:')]" - ): - text = self._clean_text(node.text_content()) - inline = re.sub(rf"^{label}[:：]?", "", text).strip() - if inline and inline != text: - return inline - sibling = node.getnext() - if sibling is not None: - sibling_text = self._clean_text(sibling.text_content()) - if sibling_text: - return sibling_text - return "" - - def _extract_userlink(self, html): - matched = re.search(r"userlink:'([^']+)'", str(html or "")) - return str(matched.group(1) or "").strip() if matched else "" - - def _extract_play_dataid(self, html, play_page_url): - root = self._parse_html(html) - if root is None: - return "" - play_path = self._extract_play_path(play_page_url) - if play_path: - for node in root.xpath(f"//a[@dataid and contains(@href,'{play_path}')]"): - dataid = str(node.get("dataid") or "").strip() - if dataid: - return dataid - return self._first_attr(root, "//a[@dataid][1]", "dataid") - - def _cache_wasm_assets(self, html): - js_rel = self._first_attr(self._parse_html(html), "//*[@id='wasm-cfg'][1]", "data-js") - wasm_rel = self._first_attr(self._parse_html(html), "//*[@id='wasm-cfg'][1]", "data-bg") - if not js_rel or not wasm_rel: - return - cache_key = f"{js_rel}|{wasm_rel}" - cached = self._wasm_asset_cache.get(cache_key) - if cached and os.path.exists(cached.get("js", "")) and os.path.exists(cached.get("wasm", "")): - self._wasm_asset_cache["active"] = cached - return - tmp_dir = tempfile.gettempdir() - js_path = os.path.join(tmp_dir, f"lianggebt_{hashlib.md5(js_rel.encode('utf-8')).hexdigest()}.mjs") - wasm_path = os.path.join(tmp_dir, f"lianggebt_{hashlib.md5(wasm_rel.encode('utf-8')).hexdigest()}.wasm") - if not os.path.exists(js_path): - response = self.fetch(self._abs_url(js_rel), headers=self.headers, timeout=15, verify=False) - if response.status_code == 200: - with open(js_path, "w", encoding="utf-8") as handle: - handle.write(response.text or "") - if not os.path.exists(wasm_path): - response = self.fetch(self._abs_url(wasm_rel), headers=self.headers, timeout=15, verify=False) - if response.status_code == 200: - with open(wasm_path, "wb") as handle: - handle.write(response.content or b"") - active = {"js": js_path, "wasm": wasm_path} - self._wasm_asset_cache[cache_key] = active - self._wasm_asset_cache["active"] = active - - def _build_wasm_play_api_url(self, dataid, secret_key, quality, userlink): - active = self._wasm_asset_cache.get("active") or {} - js_path = active.get("js", "") - wasm_path = active.get("wasm", "") - if not dataid or not secret_key or not js_path or not wasm_path: - return "" - if not os.path.exists(js_path) or not os.path.exists(wasm_path): - return "" - script = ( - "import { pathToFileURL } from 'node:url';" - "const mod = await import(pathToFileURL(process.argv[1]).href);" - "await mod.default({module_or_path: await (await import('node:fs/promises')).readFile(process.argv[2])});" - "console.log(mod.build_play_url(process.argv[3], process.argv[4], process.argv[5], process.argv[6]));" - ) - try: - result = subprocess.run( - [ - "node", - "--input-type=module", - "-e", - script, - js_path, - wasm_path, - str(dataid), - str(secret_key), - str(quality or "1080"), - str(userlink or "0"), - ], - capture_output=True, - text=True, - timeout=20, - check=False, - ) - except Exception: - return "" - if result.returncode != 0: - return "" - return self._abs_url((result.stdout or "").strip()) - - def _request_json(self, url, referer=None): - target = str(url or "").strip() - if not target: - return {} - headers = dict(self.headers) - headers["Referer"] = referer or self.headers["Referer"] - headers["Accept"] = "application/json,text/plain,*/*" - try: - response = self.fetch(target, headers=headers, timeout=15, verify=False) - except Exception: - return {} - if response.status_code != 200: - return {} - try: - return json.loads(response.text or "{}") - except Exception: - return {} - - def _extract_media_from_play_api(self, data): - payload = ((data or {}).get("data") or {}) if isinstance(data, dict) else {} - quality_urls = payload.get("quality_urls") or [] - current_quality = self._to_int(payload.get("current_quality"), 0) - ordered = [] - if 0 <= current_quality < len(quality_urls): - ordered.append(quality_urls[current_quality]) - ordered.extend([item for index, item in enumerate(quality_urls) if index != current_quality]) - for item in ordered: - url = str((item or {}).get("url") or "").strip() - if url and url != "1": - return self._abs_url(url) - return "" - - def _extract_media_url(self, html): - body = str(html or "") - patterns = [ - r'(https?://[^"\'\s<>]+\.(?:m3u8|mp4|flv|avi|mkv|ts)(?:\?[^"\'\s<>]*)?)', - r'"url"\s*:\s*"([^"]+\.(?:m3u8|mp4|flv|avi|mkv|ts)[^"]*)"', - r"'url'\s*:\s*'([^']+\.(?:m3u8|mp4|flv|avi|mkv|ts)[^']*)'", - ] - for pattern in patterns: - matched = re.search(pattern, body, re.I) - if matched: - value = matched.group(1) if matched.groups() else matched.group(0) - return self._abs_url(value) - return "" - - def _is_media_url(self, value): - return bool(re.search(r"\.(?:m3u8|mp4|flv|avi|mkv|ts)(?:\?|#|$)", str(value or ""), re.I)) - - def _build_player_result(self, url, referer): - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": str(url or ""), - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": str(referer or self.host + "/"), - "Origin": self.host, - }, - } - - def _build_parse_result(self, url, referer): - return { - "parse": 1, - "jx": 1, - "playUrl": "", - "url": str(url or ""), - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": str(referer or self.host + "/"), - "Origin": self.host, - }, - } - - def _extract_iframe_url(self, html): - matched = re.search(r']+src=["\']([^"\']+)["\']', str(html or ""), re.I) - return self._abs_url(matched.group(1)) if matched else "" - - def _abs_url(self, value): - raw = str(value or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw.lstrip("/")) - - def _parse_html(self, text): - body = str(text or "").strip() - if not body: - return None - try: - return lxml_html.fromstring(body) - except Exception: - return None - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _first_attr(self, node, xpath, attr): - if node is None: - return "" - for item in node.xpath(xpath): - value = str(item.get(attr) or "").strip() - if value: - return value - return "" - - def _first_text(self, node, xpath): - if node is None: - return "" - for item in node.xpath(xpath): - text = self._clean_text(item.text_content()) - if text: - return text - return "" - - def _to_int(self, value, default=0): - try: - return int(str(value)) - except Exception: - return default diff --git a/py/两个BT.txt b/py/两个BT.txt new file mode 100644 index 0000000..dea02e0 --- /dev/null +++ b/py/两个BT.txt @@ -0,0 +1,15 @@ +// ignore +//@name:两个BT +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:gx0MY0z9JvzEer9H +//@ek:base64:zL6R9CXHsxqYn8r/Qphs+puxkPbBDiaTHq4ZBuHqNkRIOLvRfM0NOH1mqhmcEnwT +//@hash:sha256:282687aaf9bbfacac0ccedb47cdb1e5e7b898bc023af0a076068e354f5d613fc +//@sig:base64:JXd78TyqT8agRmUPy5yRU+C2ol2UvEgG40gi/mlZyqvSH4B8SAiB9b3wg7sLOL+VXrhBslYXud0EK1uJ/X8OBA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/乌云影视.py b/py/乌云影视.py deleted file mode 100644 index c3ab217..0000000 --- a/py/乌云影视.py +++ /dev/null @@ -1,407 +0,0 @@ -# coding=utf-8 -import base64 -import json -import sys - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "乌云影视" - self.host = "https://wooyun.tv" - self.page_size = 24 - self.home_limit = 12 - self.headers = { - "Accept": "application/json, text/plain, */*", - "Origin": self.host, - "Referer": self.host + "/", - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/124.0.0.0 Safari/537.36" - ), - } - self.sort_options = [ - {"n": "默认", "v": "default"}, - {"n": "最新", "v": "latest"}, - {"n": "最热", "v": "hot"}, - {"n": "评分", "v": "score"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def _stringify(self, value): - return "" if value is None else str(value) - - def _ensure_list(self, value): - return value if isinstance(value, list) else [] - - def _normalize_ext(self, extend): - if isinstance(extend, dict): - return extend - if not extend: - return {} - try: - return json.loads(str(extend)) - except Exception: - return {} - - def _full_url(self, path): - raw = self._stringify(path).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - if raw.startswith("/"): - return self.host + raw - return self.host + "/" + raw - - def _request_json(self, path, method="GET", data=None, headers=None): - url = path if str(path).startswith("http") else self.host + path - merged_headers = dict(self.headers) - if headers: - merged_headers.update(headers) - - if method == "POST": - response = self.post(url, json=data, headers=merged_headers, timeout=15) - else: - response = self.fetch(url, headers=merged_headers, timeout=15) - - if response.status_code < 200 or response.status_code >= 300: - raise ValueError(f"{method} {path} => HTTP {response.status_code}") - - payload = response.json() - if payload.get("code") not in (None, 200) and payload.get("isSuccess") is False: - raise ValueError(payload.get("resultMsg") or str(payload.get("code"))) - return payload.get("data") - - def _build_classes(self, menu): - classes = [] - for code, fallback in [ - ("movie", "电影"), - ("tv_series", "电视剧"), - ("animation", "动画"), - ("variety", "综艺"), - ("short_drama", "短剧"), - ]: - found = next((item for item in self._ensure_list(menu) if item.get("code") == code), None) - classes.append( - {"type_id": code, "type_name": self._stringify((found or {}).get("name") or fallback)} - ) - - year_group = next((item for item in self._ensure_list(menu) if item.get("nameEn") == "year"), {}) - year_children = self._ensure_list(year_group.get("children")) - this_year = next((item for item in year_children if item.get("code") == "THIS_YEAR"), {}) - last_year = next((item for item in year_children if item.get("code") == "LAST_YEAR"), {}) - classes.append({"type_id": "THIS_YEAR", "type_name": self._stringify(this_year.get("name") or "今年")}) - classes.append({"type_id": "LAST_YEAR", "type_name": self._stringify(last_year.get("name") or "去年")}) - return classes - - def _build_filters(self, menu, classes): - option_map = {"genre": [], "region": [], "year": [], "language": []} - for group in self._ensure_list(menu): - values = [] - for item in self._ensure_list(group.get("children")): - code = self._stringify(item.get("code")) - name = self._stringify(item.get("name") or item.get("nameEn") or code) - if code and name and code not in ("THIS_YEAR", "LAST_YEAR"): - values.append({"n": name, "v": code}) - if group.get("nameEn") in option_map: - option_map[group.get("nameEn")] = values - - filters = {} - for cls in classes: - items = [] - if option_map["year"]: - items.append( - { - "key": "year", - "name": "年份", - "init": "", - "value": [{"n": "全部", "v": ""}] + option_map["year"], - } - ) - if option_map["region"]: - items.append( - { - "key": "region", - "name": "地区", - "init": "", - "value": [{"n": "全部", "v": ""}] + option_map["region"], - } - ) - if option_map["genre"] and cls["type_id"] in ( - "movie", - "tv_series", - "animation", - "variety", - "short_drama", - ): - items.append( - { - "key": "genre", - "name": "类型", - "init": "", - "value": [{"n": "全部", "v": ""}] + option_map["genre"], - } - ) - if option_map["language"]: - items.append( - { - "key": "lang", - "name": "语言", - "init": "", - "value": [{"n": "全部", "v": ""}] + option_map["language"], - } - ) - items.append({"key": "sort", "name": "排序", "init": "default", "value": self.sort_options}) - filters[cls["type_id"]] = items - return filters - - def _map_top_code(self, category_id): - mapping = { - "movie": "movie", - "tv_series": "tv_series", - "animation": "animation", - "variety": "variety", - "short_drama": "short_drama", - "THIS_YEAR": "movie", - "LAST_YEAR": "movie", - } - return mapping.get(category_id, "movie") - - def _build_category_body(self, category_id, page, extend): - filters = self._normalize_ext(extend) - menu_code_list = [] - if category_id not in ("movie", "tv_series", "animation", "variety", "short_drama"): - menu_code_list.append(category_id) - for key in ("genre", "region", "year", "lang", "other"): - value = self._stringify(filters.get(key)) - if value and value not in menu_code_list: - menu_code_list.append(value) - return { - "menuCodeList": menu_code_list, - "pageIndex": self._stringify(page or 1), - "pageSize": self.page_size, - "searchKey": "", - "sortCode": "" if filters.get("sort") in (None, "", "default") else self._stringify(filters.get("sort")), - "topCode": self._map_top_code(category_id), - } - - def _join_text(self, value): - return "/".join([self._stringify(item) for item in self._ensure_list(value) if self._stringify(item)]) - - def _pick_poster(self, item): - return self._stringify( - item.get("posterUrlS3") or item.get("posterUrl") or item.get("thumbUrlS3") or item.get("thumbUrl") - ) - - def _extract_home_list(self, home_blocks): - if isinstance(home_blocks, dict): - blocks = self._ensure_list(home_blocks.get("records")) - else: - blocks = self._ensure_list(home_blocks) - seen = set() - items = [] - for block in blocks: - for item in self._ensure_list(block.get("mediaResources")): - vod_id = self._stringify(item.get("id")) - if not vod_id or vod_id in seen: - continue - seen.add(vod_id) - copied = dict(item) - copied["id"] = vod_id - items.append(copied) - return items - - def _map_vod(self, item): - media_type = item.get("mediaType") or {} - return { - "vod_id": self._stringify(item.get("id")), - "vod_name": self._stringify(item.get("title")), - "vod_pic": self._pick_poster(item), - "type_id": self._stringify(media_type.get("code")), - "type_name": self._stringify(media_type.get("name")), - "vod_remarks": self._stringify(item.get("episodeStatus") or item.get("remark")), - "vod_year": self._stringify(item.get("releaseYear")), - "vod_douban_score": self._stringify(item.get("rating")), - "vod_actor": self._join_text(item.get("actors")), - "vod_director": self._join_text(item.get("directors")), - } - - def homeContent(self, filter): - menu = self._request_json("/movie/category/menu") - classes = self._build_classes(menu) - return {"class": classes, "filters": self._build_filters(menu, classes)} - - def homeVideoContent(self): - data = self._request_json(f"/movie/media/home/custom/classify/1/3?limit={self.home_limit}") - items = self._extract_home_list(data)[: self.home_limit] - return {"list": [self._map_vod(item) for item in items]} - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - data = self._request_json( - "/movie/media/search", - method="POST", - data=self._build_category_body(self._stringify(tid or "movie"), page, extend), - headers={"Content-Type": "application/json"}, - ) or {} - records = [self._map_vod(item) for item in self._ensure_list(data.get("records"))] - total = int(data.get("total") or 0) - return {"page": page, "limit": self.page_size, "total": total, "list": records} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._stringify(key).strip() - if not keyword: - return {"page": page, "total": 0, "list": []} - - data = self._request_json( - "/movie/media/search", - method="POST", - data={ - "menuCodeList": [], - "pageIndex": self._stringify(page), - "pageSize": self.page_size, - "searchKey": keyword, - "sortCode": "", - "topCode": "", - }, - headers={"Content-Type": "application/json"}, - ) or {} - records = [self._map_vod(item) for item in self._ensure_list(data.get("records"))] - total = int(data.get("total") or 0) - return {"page": page, "total": total, "list": records} - - def _encode_play_payload(self, payload): - raw = json.dumps(payload, ensure_ascii=False).encode("utf-8") - return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=") - - def _decode_play_id(self, play_id): - raw = self._stringify(play_id).strip() - padding = "=" * (-len(raw) % 4) - try: - return json.loads(base64.urlsafe_b64decode((raw + padding).encode("utf-8")).decode("utf-8")) - except Exception: - return {"mediaId": "", "playUrl": ""} - - def _build_play_sources(self, seasons, media_id): - season_list = self._ensure_list(seasons) - multiple = len(season_list) > 1 - from_list = [] - url_list = [] - for index, season in enumerate(season_list, start=1): - season_no = season.get("seasonNo") or index - episode_entries = [] - for video_index, video in enumerate(self._ensure_list(season.get("videoList")), start=1): - ep_no = int(video.get("epNo") or video_index) - remark = self._stringify(video.get("remark")).strip() - if ep_no > 0: - name = f"第{ep_no}集" if not remark else f"第{ep_no}集 {remark}" - else: - name = remark or "正片" - payload = self._encode_play_payload( - { - "mediaId": self._stringify(media_id), - "seasonNo": season_no, - "epNo": ep_no, - "videoId": video.get("id"), - "playUrl": video.get("playUrl"), - "name": name, - } - ) - episode_entries.append(f"{name}${payload}") - if episode_entries: - from_list.append( - f"第{season_no}季" - if multiple - else self._stringify(season.get("lineName") or season.get("title") or self.name) - ) - url_list.append("#".join(episode_entries)) - return {"vod_play_from": "$$$".join(from_list), "vod_play_url": "$$$".join(url_list)} - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - media_id = self._stringify(raw_id).strip() - if not media_id: - continue - base_detail = self._request_json(f"/movie/media/base/detail?mediaId={media_id}") or {} - detail = self._request_json(f"/movie/media/detail?mediaId={media_id}") or {} - seasons = self._request_json( - f"/movie/media/video/list?mediaId={media_id}&lineName=&resolutionCode=" - ) or [] - merged = detail or base_detail - play_data = self._build_play_sources(seasons, media_id) - result["list"].append( - { - "vod_id": self._stringify(merged.get("id") or media_id), - "vod_name": self._stringify(merged.get("title") or base_detail.get("title")), - "vod_pic": self._pick_poster(merged or base_detail), - "type_id": self._stringify((merged.get("mediaType") or {}).get("code")), - "type_name": self._stringify((merged.get("mediaType") or {}).get("name")), - "vod_remarks": self._stringify(merged.get("episodeStatus")), - "vod_year": self._stringify(merged.get("releaseYear")), - "vod_area": self._stringify(merged.get("region")), - "vod_actor": self._join_text(merged.get("actors")), - "vod_director": self._join_text(merged.get("directors")), - "vod_content": self._stringify(merged.get("overview") or merged.get("description")), - "vod_douban_score": self._stringify(merged.get("rating")), - **play_data, - } - ) - return result - - def _find_play_url(self, seasons, target): - for season in self._ensure_list(seasons): - if target.get("seasonNo") is not None and int(season.get("seasonNo") or 0) != int(target.get("seasonNo")): - continue - for video in self._ensure_list(season.get("videoList")): - if target.get("videoId") is not None and int(video.get("id") or 0) == int(target.get("videoId")): - return self._stringify(video.get("playUrl")) - if target.get("epNo") is not None and int(video.get("epNo") or 0) == int(target.get("epNo")): - return self._stringify(video.get("playUrl")) - - first_season = self._ensure_list(seasons)[0] if self._ensure_list(seasons) else {} - first_video = ( - self._ensure_list(first_season.get("videoList"))[0] - if self._ensure_list(first_season.get("videoList")) - else {} - ) - return self._stringify(first_video.get("playUrl")) - - def playerContent(self, flag, id, vipFlags): - payload = self._decode_play_id(self._stringify(id).strip()) - final_url = self._stringify(payload.get("playUrl")) - if not final_url and payload.get("mediaId"): - seasons = self._request_json( - f"/movie/media/video/list?mediaId={payload['mediaId']}&lineName=&resolutionCode=" - ) or [] - final_url = self._find_play_url(seasons, payload) - - if not final_url: - return {"parse": 1, "jx": 1, "url": self._stringify(id), "header": dict(self.headers)} - - return { - "parse": 0, - "jx": 0, - "url": self._full_url(final_url), - "header": { - "Referer": self.host + "/", - "Origin": self.host, - "User-Agent": self.headers["User-Agent"], - }, - } diff --git a/py/乌云影视.txt b/py/乌云影视.txt new file mode 100644 index 0000000..cbb54b7 --- /dev/null +++ b/py/乌云影视.txt @@ -0,0 +1,15 @@ +// ignore +//@name:乌云影视 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:tyMSG+YEMzP+aZzZ +//@ek:base64:KBo5xYqzioVYjVkoLFew4O7kRC0Fj3j+IIGsBovo75jesmksh7UaLRbTPtGC3Oer +//@hash:sha256:20a685907520e17f3516c5c4a216a41853f3b05453f4c7ad9f5e245e295f841c +//@sig:base64:MXAmFGVLiI7uvg+venMLmFMoDgq9lyuwbyUG98HHRZQZ4Ifm4SpVGEl7aqSsn7T+vokj5CC9DG6qf++RsZaaCQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/乐兔.py b/py/乐兔.py deleted file mode 100644 index 2665efa..0000000 --- a/py/乐兔.py +++ /dev/null @@ -1,267 +0,0 @@ -# coding=utf-8 -import base64 -import json -import re -import sys -from urllib.parse import quote, unquote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "乐兔" - self.host = "https://www.letu.me" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/144.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.categories = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "电视剧"}, - {"type_id": "3", "type_name": "综艺"}, - {"type_id": "4", "type_name": "动漫"}, - {"type_id": "5", "type_name": "短剧"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _encode_vod_id(self, href): - matched = re.search(r"/(vods|vod|detail)/([^/?#]+)\.html", self._build_url(href)) - return f"{matched.group(1)}/{matched.group(2)}" if matched else "" - - def _decode_vod_id(self, vod_id): - matched = re.search(r"^(vods|vod|detail)/([^/?#]+)$", str(vod_id or "").strip()) - return self._build_url(f"/{matched.group(1)}/{matched.group(2)}.html") if matched else "" - - def _encode_play_id(self, href): - matched = re.search(r"/(vod|vodplay|play)/([^/?#]+)\.html", self._build_url(href)) - return f"{matched.group(1)}/{matched.group(2)}" if matched else "" - - def _decode_play_id(self, play_id): - matched = re.search(r"^(vod|vodplay|play)/([^/?#]+)$", str(play_id or "").strip()) - return self._build_url(f"/{matched.group(1)}/{matched.group(2)}.html") if matched else "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "")).strip() - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for node in root.xpath("//*[contains(@class,'grid') and contains(@class,'container_list')]//*[contains(@class,'s6')]"): - href = "".join(node.xpath(".//a[1]/@href")).strip() - vod_id = self._encode_vod_id(href) - if not vod_id or vod_id in seen: - continue - name = self._clean_text("".join(node.xpath(".//a[1]/@title")) or "".join(node.xpath(".//a[1]//text()"))) - if not name: - continue - pic = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'large')][1]/@data-src | .//*[contains(@class,'large')][1]/@src")) - ) - remark = self._clean_text("".join(node.xpath(".//*[contains(@class,'small-text')][1]//text()"))) - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": name, - "vod_pic": self._build_url(pic), - "vod_remarks": remark, - } - ) - return items - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def _build_category_url(self, tid, pg): - page = int(pg) - if page <= 1: - return self._build_url(f"/type/{tid}.html") - return self._build_url(f"/type/{tid}-{page}.html") - - def categoryContent(self, tid, pg, filter, extend): - html = self._request_html(self._build_category_url(tid, pg)) - return self._page_result(self._parse_cards(html), pg) - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - if not keyword: - return self._page_result([], pg) - html = self._request_html(self._build_url(f"/vodsearch/-------------.html?wd={quote(keyword)}")) - root = self.html(html) - if root is None: - return self._page_result([], pg) - items = [] - for node in root.xpath("//*[contains(@class,'result-list')]//*[contains(@class,'result-item')]"): - href = "".join(node.xpath(".//a[1]/@href")).strip() - vod_id = self._encode_vod_id(href) - name = self._clean_text("".join(node.xpath(".//a[1]//text()"))) - if not vod_id or not name: - continue - pic = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'large')][1]/@data-src | .//*[contains(@class,'large')][1]/@src")) - ) - remark = self._clean_text("".join(node.xpath(".//*[contains(@class,'small-text')][1]//text()"))) - items.append( - { - "vod_id": vod_id, - "vod_name": name, - "vod_pic": self._build_url(pic), - "vod_remarks": remark, - } - ) - return self._page_result(items, pg) - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - if root is None: - return {"list": []} - info_nodes = root.xpath( - "//*[contains(concat(' ', normalize-space(@class), ' '), ' no-margin ') and " - "contains(concat(' ', normalize-space(@class), ' '), ' m ') and " - "contains(concat(' ', normalize-space(@class), ' '), ' l ')]" - ) - director = "" - area = "" - for node in info_nodes: - classes = " ".join(node.xpath("./@class")) - text = self._clean_text("".join(node.xpath(".//text()"))) - if not text: - continue - if "no-space" in classes and not director: - director = text - elif "no-space" not in classes and not area: - area = text - play_from = [] - play_urls = [] - tabs = [ - self._clean_text("".join(node.xpath(".//text()"))) - for node in root.xpath("//*[contains(@class,'tabs') and contains(@class,'left-align')]//a") - ] - groups = root.xpath("//*[contains(@class,'playno')]") - for index, group in enumerate(groups): - episodes = [] - for anchor in group.xpath(".//a[@href]"): - play_id = self._encode_play_id("".join(anchor.xpath("./@href"))) - ep_name = self._clean_text("".join(anchor.xpath(".//text()"))) - if play_id and ep_name: - episodes.append(f"{ep_name}${play_id}") - if episodes: - play_from.append(tabs[index] if index < len(tabs) and tabs[index] else f"线路{index + 1}") - play_urls.append("#".join(episodes)) - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath("//h1[1]//text()"))), - "vod_pic": self._build_url("".join(root.xpath("(//img/@src | //img/@data-src)[1]"))), - "type_name": self._clean_text( - "".join(root.xpath("(//*[contains(@class,'scroll') and contains(@class,'no-margin')]//a[1]//text())[1]")) - ), - "vod_actor": self._clean_text( - "".join(root.xpath("(//*[contains(@class,'scroll') and contains(@class,'no-margin')]//a[2]//text())[1]")) - ), - "vod_director": director, - "vod_area": area, - "vod_content": self._clean_text("".join(root.xpath("(//*[contains(@class,'responsive')]//p[last()]//text())[1]"))), - "vod_play_from": "$$$".join(play_from), - "vod_play_url": "$$$".join(play_urls), - } - ] - } - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail_url = self._decode_vod_id(vod_id) or self._build_url(vod_id) - if not detail_url: - continue - parsed = self._parse_detail_page(self._request_html(detail_url), vod_id) - result["list"].extend(parsed.get("list", [])) - return result - - def _base64_decode(self, value): - text = re.sub(r"\s+", "", str(value or "")) - text += "=" * ((4 - len(text) % 4) % 4) - try: - return base64.b64decode(text).decode("utf-8") - except Exception: - return "" - - def _decode_rose_url(self, value): - raw = str(value or "")[5:] - decoded = self._base64_decode(unquote(raw)) - if decoded: - return decoded - return self._base64_decode(raw) - - def _extract_player_data(self, html): - matched = re.search(r"player_[a-z0-9]+\s*=\s*(\{[\s\S]*?\})", str(html or ""), re.I) - if not matched: - return None - try: - return json.loads(matched.group(1)) - except Exception: - return None - - def playerContent(self, flag, id, vipFlags): - play_url = self._decode_play_id(id) or self._build_url(id) - body = self._request_html(play_url) - try: - payload = json.loads(body) - except Exception: - payload = None - if isinstance(payload, dict) and str(payload.get("code")) == "200" and payload.get("url"): - video_url = str(payload.get("url")) - if video_url.startswith("rose_"): - video_url = self._decode_rose_url(video_url) - elif video_url.startswith("/"): - video_url = self._build_url(video_url) - if video_url: - return {"parse": 0, "jx": 0, "url": video_url, "header": dict(self.headers)} - player = self._extract_player_data(body) - if player: - video_url = str(player.get("url") or "") - encrypt = str(player.get("encrypt") or "") - if encrypt == "1": - video_url = unquote(video_url) - elif encrypt == "2": - video_url = self._base64_decode(unquote(video_url)) - if video_url: - return {"parse": 0, "jx": 0, "url": video_url, "header": dict(self.headers)} - return {"parse": 1, "jx": 1, "url": play_url, "header": dict(self.headers)} diff --git a/py/乐兔.txt b/py/乐兔.txt new file mode 100644 index 0000000..bae1011 --- /dev/null +++ b/py/乐兔.txt @@ -0,0 +1,15 @@ +// ignore +//@name:乐兔 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:qJM7/0yU09L0+cxp +//@ek:base64:1Z7hp6wEhtm8KowXuk5V2jBdHAk1/AIQJdjf9YPneFNgBZ/37hIChDYj8fluzxoU +//@hash:sha256:8faee451746c790ada3d103358636a17c37340b96f5ea5d36190fb0738dde584 +//@sig:base64:17Ahdjwis9LDzvlWyta86/aG4Im/x8NfMYeqrJXnSHYYEhOSWk4LpumcuD3U+H2ZT0Sk+zdWkVT68Ebi8CWmAA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/二小.py b/py/二小.py deleted file mode 100644 index 0cc41ad..0000000 --- a/py/二小.py +++ /dev/null @@ -1,269 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "二小" - self.host = "https://www.2xiaopan.top" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.categories = [ - {"type_id": "1", "type_name": "二小电影"}, - {"type_id": "2", "type_name": "二小剧集"}, - {"type_id": "3", "type_name": "二小动漫"}, - {"type_id": "17", "type_name": "二小综艺"}, - ] - self.pan_patterns = [ - ("baidu", "百度资源", r"pan\.baidu\.com|yun\.baidu\.com"), - ("a139", "139资源", r"yun\.139\.com"), - ("a189", "天翼资源", r"cloud\.189\.cn"), - ("a123", "123资源", r"123684\.com|123865\.com|123912\.com|123pan\.com"), - ("a115", "115资源", r"115\.com"), - ("quark", "夸克资源", r"pan\.quark\.cn"), - ("xunlei", "迅雷资源", r"pan\.xunlei\.com"), - ("aliyun", "阿里资源", r"aliyundrive\.com|alipan\.com"), - ("uc", "UC资源", r"drive\.uc\.cn"), - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _class_xpath(self, class_name): - return f"contains(concat(' ', normalize-space(@class), ' '), ' {class_name} ')" - - def _detect_pan_type(self, url): - raw = str(url or "").strip() - for pan_type, title, pattern in self.pan_patterns: - if re.search(pattern, raw, re.I): - return pan_type, title - return "", "" - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - item_xpath = self._class_xpath("module-item") - pic_box_xpath = self._class_xpath("module-item-pic") - text_xpath = self._class_xpath("module-item-text") - caption_xpath = self._class_xpath("module-item-caption") - for node in root.xpath(f"//*[@id='main']//*[{item_xpath}]"): - href = "".join(node.xpath(f".//*[{pic_box_xpath}]//a[1]/@href")).strip() - title = "".join(node.xpath(f".//*[{pic_box_xpath}]//img[1]/@alt")).strip() - pic = ( - "".join(node.xpath(f".//*[{pic_box_xpath}]//img[1]/@data-src")).strip() - or "".join(node.xpath(f".//*[{pic_box_xpath}]//img[1]/@src")).strip() - ) - remarks = self._clean_text("".join(node.xpath(f".//*[{text_xpath}][1]//text()"))) - year = self._clean_text("".join(node.xpath(f".//*[{caption_xpath}][1]//span[1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - "vod_year": year, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_url(f"/index.php/vod/show/id/{tid}/page/{int(pg)}.html") - return self._page_result(self._parse_cards(self._request_html(url)), pg) - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - page = int(pg) - if not keyword: - return {"page": page, "total": 0, "list": []} - - url = self._build_url(f"/index.php/vod/search/page/{page}/wd/{quote(keyword)}.html") - root = self.html(self._request_html(url)) - if root is None: - return {"page": page, "total": 0, "list": []} - - items = [] - search_item_xpath = self._class_xpath("module-search-item") - video_serial_xpath = self._class_xpath("video-serial") - pic_box_xpath = self._class_xpath("module-item-pic") - text_xpath = self._class_xpath("module-item-text") - for node in root.xpath(f"//*[{search_item_xpath}]"): - href = "".join(node.xpath(f".//*[{video_serial_xpath}][1]/@href")).strip() - title = "".join(node.xpath(f".//*[{video_serial_xpath}][1]/@title")).strip() - pic = ( - "".join(node.xpath(f".//*[{pic_box_xpath}]//img[1]/@data-src")).strip() - or "".join(node.xpath(f".//*[{pic_box_xpath}]//img[1]/@src")).strip() - ) - remarks = self._clean_text( - "".join(node.xpath(f".//*[{video_serial_xpath}][1]//text()")) - or "".join(node.xpath(f".//*[{text_xpath}][1]//text()")) - ) - if not href or not title: - continue - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return {"page": page, "total": len(items), "list": items} - - def _parse_detail_page(self, vod_id, html): - root = self.html(html) - if root is None: - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - mobile_play_xpath = self._class_xpath("mobile-play") - lazyload_xpath = self._class_xpath("lazyload") - page_title_xpath = self._class_xpath("page-title") - info_title_xpath = self._class_xpath("video-info-itemtitle") - row_info_xpath = self._class_xpath("module-row-info") - - pic_candidates = root.xpath( - "(" - f"//*[{mobile_play_xpath}]//*[{lazyload_xpath}]/@data-src | " - f"//*[{mobile_play_xpath}]//*[{lazyload_xpath}]/@src" - ")[1]" - ) - - detail = { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath(f"//*[{page_title_xpath}][1]//text()"))), - "vod_pic": self._build_url((pic_candidates[0] if pic_candidates else "").strip()), - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - for label_node in root.xpath(f"//*[{info_title_xpath}]"): - key = self._clean_text("".join(label_node.xpath(".//text()"))) - sibling = label_node.getnext() - if sibling is None: - continue - values = [self._clean_text(text) for text in sibling.xpath(".//a//text()")] - joined = ",".join([value for value in values if value]) - text_value = self._clean_text("".join(sibling.xpath(".//text()"))) - if "年代" in key: - detail["vod_year"] = joined or text_value - elif "导演" in key: - detail["vod_director"] = joined or text_value - elif "主演" in key: - detail["vod_actor"] = joined or text_value - elif "剧情" in key: - detail["vod_content"] = text_value - - for node in root.xpath(f"//*[{row_info_xpath}]//p"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if text: - detail["pan_urls"].append(text) - return detail - - def _build_pan_lines(self, detail): - lines = [] - seen = set() - for url in detail.get("pan_urls", []): - pan_type, title = self._detect_pan_type(url) - if not pan_type or url in seen: - continue - seen.add(url) - lines.append((self.pan_priority.get(pan_type, 999), f"{pan_type}#二小", f"{title}${url}")) - lines.sort(key=lambda item: item[0]) - return [(item[1], item[2]) for item in lines] - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail = self._parse_detail_page(vod_id, self._request_html(self._build_url(vod_id))) - lines = self._build_pan_lines(detail) - result["list"].append( - { - "vod_id": vod_id, - "vod_name": detail["vod_name"], - "vod_pic": detail["vod_pic"], - "vod_year": detail["vod_year"], - "vod_director": detail["vod_director"], - "vod_actor": detail["vod_actor"], - "vod_content": detail["vod_content"], - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - pan_type, _ = self._detect_pan_type(id) - if pan_type: - return {"parse": 0, "playUrl": "", "url": id} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/二小.txt b/py/二小.txt new file mode 100644 index 0000000..31bfae3 --- /dev/null +++ b/py/二小.txt @@ -0,0 +1,15 @@ +// ignore +//@name:二小 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:vonA8S+0KqlB/lNx +//@ek:base64:q5E8Bmc+eY0YkJ74mwQY3p5uue/QD7awb9P8Z2WKRU1ZtRQtAdvFmbKhsyeVMX/Y +//@hash:sha256:f37c5a90087933c1c5d8817a58b92865cc249c304bf187edd37b40b49452360f +//@sig:base64:f/QjbtEvJ1G9SNrd785UVGoDrXrJvd82Q10rvGP/1qnfm28una0+NEOL7WBqGeQBp7aZAF7pp8H0fCcnqKtuDw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/人人电影.py b/py/人人电影.py deleted file mode 100644 index 2c8398a..0000000 --- a/py/人人电影.py +++ /dev/null @@ -1,251 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "人人电影" - self.host = "https://www.rrdynb.com" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.categories = [ - {"type_id": "movie/list_2", "type_name": "电影"}, - {"type_id": "dianshiju/list_6", "type_name": "电视剧"}, - {"type_id": "dongman/list_13", "type_name": "动漫"}, - {"type_id": "zongyi/list_10", "type_name": "老电影"}, - ] - self.supported_pan_patterns = [ - r"pan\.baidu\.com|yun\.baidu\.com", - r"pan\.quark\.cn", - r"drive\.uc\.cn", - r"115\.com", - r"123pan\.com|123684\.com|123865\.com|123912\.com", - r"cloud\.189\.cn", - r"yun\.139\.com", - ] - self.excluded_pan_patterns = [ - r"pan\.xunlei\.com", - r"aliyundrive\.com", - r"alipan\.com", - ] - self.pan_type_patterns = [ - ("baidu", r"pan\.baidu\.com|yun\.baidu\.com"), - ("quark", r"pan\.quark\.cn"), - ("uc", r"drive\.uc\.cn"), - ("115", r"115\.com"), - ("123pan", r"123pan\.com|123684\.com|123865\.com|123912\.com"), - ("189", r"cloud\.189\.cn"), - ("139", r"yun\.139\.com"), - ] - self.pan_priority = { - "baidu": 1, - "quark": 2, - "uc": 3, - "115": 4, - "123pan": 5, - "189": 6, - "139": 7, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - raw = str(path or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - return urljoin(self.host + "/", raw) - - def _clean_search_title(self, text): - return str(text or "").replace("", "").replace("", "").strip() - - def _normalize_title(self, raw_title): - cleaned = self._clean_search_title(raw_title) - matched = re.search(r"《(.*?)》|「(.*?)」", cleaned) - if matched: - return (matched.group(1) or matched.group(2) or "").strip() - return cleaned.strip() - - def _is_supported_pan_url(self, url): - raw = str(url or "").strip() - if not raw: - return False - if any(re.search(pattern, raw, re.I) for pattern in self.excluded_pan_patterns): - return False - return any(re.search(pattern, raw, re.I) for pattern in self.supported_pan_patterns) - - def _detect_pan_type(self, url): - raw = str(url or "").strip() - for pan_type, pattern in self.pan_type_patterns: - if re.search(pattern, raw, re.I): - return pan_type - return "" - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _first_xpath_result(self, node, expr): - for value in node.xpath(expr): - text = str(value or "").strip() - if text: - return text - return "" - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for node in root.xpath("//*[@id='movielist']//li"): - href = self._first_xpath_result(node, ".//*[contains(@class,'intro')]//h2//a/@href") - title = ( - self._first_xpath_result(node, ".//*[contains(@class,'intro')]//h2//a/@title") - or self._first_xpath_result(node, ".//*[contains(@class,'intro')]//h2//a//text()") - ) - pic = ( - self._first_xpath_result(node, ".//*[contains(@class,'pure-img')][1]/@data-original") - or self._first_xpath_result(node, ".//*[contains(@class,'pure-img')][1]/@src") - or self._first_xpath_result(node, ".//*[contains(@class,'pure-img')]//img[1]/@data-original") - or self._first_xpath_result(node, ".//*[contains(@class,'pure-img')]//img[1]/@src") - or self._first_xpath_result(node, ".//*[contains(@class,'pure-u-5-24')]//img[1]/@data-original") - or self._first_xpath_result(node, ".//*[contains(@class,'pure-u-5-24')]//img[1]/@src") - ) - remarks = self._clean_text("".join(node.xpath(".//*[contains(@class,'dou')][1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": self._normalize_title(title), - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - class_path = str(tid or "").lstrip("/") - url = self._build_url(f"{class_path}.html" if page <= 1 else f"{class_path}_{page}.html") - items = self._parse_cards(self._request_html(url)) - return {"page": page, "limit": len(items), "total": page * 30 + len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - - url = self._build_url(f"/plus/search.php?q={quote(keyword)}&pagesize=10&submit=") - if page > 1: - url += f"&PageNo={page}" - - items = self._parse_cards(self._request_html(url)) - return {"page": page, "total": len(items), "list": items} - - def _extract_pan_links(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for node in root.xpath("//*[contains(@class,'movie-txt')]//a[@href]"): - href = "".join(node.xpath("./@href")).strip() - title = self._clean_text("".join(node.xpath(".//text()"))) or "网盘资源" - if not self._is_supported_pan_url(href) or href in seen: - continue - seen.add(href) - items.append((title, href)) - return items - - def _build_pan_lines(self, pan_links): - grouped = {} - order_seen = [] - for title, url in pan_links: - pan_type = self._detect_pan_type(url) - if not pan_type: - continue - if pan_type not in grouped: - grouped[pan_type] = [] - order_seen.append(pan_type) - existing_urls = {item.split("$", 1)[1] for item in grouped[pan_type]} - if url not in existing_urls: - grouped[pan_type].append(f"{title}${url}") - names = sorted(order_seen, key=lambda name: self.pan_priority.get(name, 999)) - return [(name, "#".join(grouped[name])) for name in names if grouped[name]] - - def _parse_detail(self, vod_id, html): - root = self.html(html) - if root is None: - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_content": "", - "vod_play_from": "", - "vod_play_url": "", - } - - vod_name = self._clean_text("".join(root.xpath("//*[contains(@class,'movie-des')]//h1[1]//text()"))) - vod_pic = self._build_url("".join(root.xpath("//*[contains(@class,'movie-img')]//img[1]/@src")).strip()) - vod_content = self._clean_text("".join(root.xpath("//*[contains(@class,'movie-txt')][1]//text()"))) - lines = self._build_pan_lines(self._extract_pan_links(html)) - return { - "vod_id": vod_id, - "vod_name": vod_name, - "vod_pic": vod_pic, - "vod_content": vod_content, - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail = self._parse_detail(vod_id, self._request_html(self._build_url(vod_id))) - result["list"].append(detail) - return result - - def playerContent(self, flag, id, vipFlags): - url = str(id or "").strip() - if self._is_supported_pan_url(url): - return {"parse": 0, "playUrl": "", "url": url} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/人人电影.txt b/py/人人电影.txt new file mode 100644 index 0000000..37c3194 --- /dev/null +++ b/py/人人电影.txt @@ -0,0 +1,15 @@ +// ignore +//@name:人人电影 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:x6EkWQL5rQzIsVMa +//@ek:base64:XQ11TAcPz6JOR4uaTvXYgDsu4TQXjFzjxjbMWNHDr8E0WpZPoGrNyeDU6YBEJD9T +//@hash:sha256:4790ec0c5de700f33962d96a404bf10cfabc2265a7cc94bd9315ef7e01cc9caa +//@sig:base64:RZ65vdPgNCGprh44FqdXpfdt0VNOOHKHkI7S6j4PWpUt7cu/qK4u9ZS47hUFF/QuTJohPCx9NCZ8rGQd/OojDg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/人人视频.py b/py/人人视频.py deleted file mode 100644 index 3eb527d..0000000 --- a/py/人人视频.py +++ /dev/null @@ -1,340 +0,0 @@ -# coding=utf-8 -import base64 -import hashlib -import hmac -import json -import sys -import time - -from Crypto.Cipher import AES -from Crypto.Util.Padding import pad, unpad - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -HOST = "https://m.yichengwlkj.com" -API_URL = "https://api.rrmj.plus" -UA = ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0" -) -KY_ID = "BA21A0F5-7C57-41BA-8665-B7164A131832" -APP_SECRET = "ES513W0B1CsdUrR13Qk5EgDAKPeeKZY" -AES_KEY = "3b744389882a4067" -AES_IV = "b1da7878016e4e2b" - - -class Spider(BaseSpider): - def __init__(self): - self.name = "人人视频" - self.class_name_map = { - "TV": "剧集", - "MOVIE": "电影", - "VARIETY": "综艺", - "COMIC": "动漫", - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeVideoContent(self): - return {"list": []} - - def _stringify(self, value): - return "" if value is None else str(value) - - def _build_api_url(self, path): - return f"{API_URL}{str(path or '').strip()}" - - def _join_values(self, *values): - return " ".join([self._stringify(value).strip() for value in values if self._stringify(value).strip()]).strip() - - def _generate_signature(self, text): - digest = hmac.new(APP_SECRET.encode("utf-8"), text.encode("utf-8"), hashlib.sha256).digest() - return base64.b64encode(digest).decode("utf-8") - - def _create_headers(self, url_path, params=None, method="GET"): - payload = { - self._stringify(key): self._stringify(value) - for key, value in dict(params or {}).items() - } - timestamp = str(int(time.time() * 1000)) - sorted_params = "&".join([f"{key}={payload[key]}" for key in sorted(payload)]) - full_url = f"{url_path}?{sorted_params}" if sorted_params else url_path - string_to_sign = "\n".join( - [ - method.upper(), - f"aliId:{KY_ID}", - "ct:web_pc", - "cv:1.0.0", - f"t:{timestamp}", - full_url, - ] - ) - headers = { - "Accept": "application/json, text/plain, */*", - "User-Agent": UA, - "Origin": HOST, - "Referer": HOST, - "aliId": KY_ID, - "clientType": "web_pc", - "clientVersion": "1.0.0", - "ct": "web_pc", - "cv": "1.0.0", - "deviceId": KY_ID, - "t": timestamp, - "token": "", - "uet": "9", - "umid": KY_ID, - "x-ca-sign": self._generate_signature(string_to_sign), - } - if method.upper() == "POST": - headers["Content-Type"] = "application/json;charset=UTF-8" - return headers - - def _decrypt_aes_ecb(self, encrypted_data): - text = self._stringify(encrypted_data).strip() - if not text: - return None - if text.startswith("{") or text.startswith("["): - try: - return json.loads(text) - except Exception: - return None - try: - clean = "".join(text.split()) - cipher = AES.new(AES_KEY.encode("utf-8"), AES.MODE_ECB) - raw = base64.b64decode(clean) - decoded = unpad(cipher.decrypt(raw), AES.block_size).decode("utf-8") - return json.loads(decoded) - except Exception: - return None - - def _decrypt_aes_cbc(self, encrypted_text, new_sign): - text = self._stringify(encrypted_text).strip() - sign = self._stringify(new_sign).strip() - if not text or len(sign) < 20: - return "" - try: - key = sign[4:20].encode("utf-8") - cipher = AES.new(key, AES.MODE_CBC, AES_IV.encode("utf-8")) - decoded = unpad(cipher.decrypt(base64.b64decode(text)), AES.block_size).decode("utf-8") - return decoded - except Exception: - return "" - - def _request_api(self, url_path, params=None, method="GET"): - payload = dict(params or {}) - headers = self._create_headers(url_path, payload, method=method) - try: - if method.upper() == "POST": - response = self.post( - self._build_api_url(url_path), - headers=headers, - json=payload, - timeout=10, - verify=False, - ) - else: - response = self.fetch( - self._build_api_url(url_path), - params=payload, - headers=headers, - timeout=10, - verify=False, - ) - except Exception: - return None - if getattr(response, "status_code", 0) != 200: - return None - return self._decrypt_aes_ecb(getattr(response, "text", "")) - - def _build_filter_values(self, items): - values = [] - for item in items or []: - name = self._stringify(item.get("displayName")) - value = self._stringify(item.get("value")) - if not name: - continue - values.append({"n": name, "v": value}) - return values - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def homeContent(self, filter): - payload = self._request_api("/m-station/drama/get_drama_filter") or {} - groups = { - self._stringify(item.get("filterType")): list(item.get("dramaFilterItemList") or []) - for item in payload.get("data", []) - } - classes = [] - filters = {} - for item in groups.get("dramaType", []): - type_id = self._stringify(item.get("value")) - if type_id not in self.class_name_map: - continue - classes.append({"type_id": type_id, "type_name": self.class_name_map[type_id]}) - filters[type_id] = [ - {"key": "area", "name": "地区", "value": self._build_filter_values(groups.get("area", []))}, - {"key": "class", "name": "类型", "value": self._build_filter_values(groups.get("plotType", []))}, - {"key": "year", "name": "年份", "value": self._build_filter_values(groups.get("year", []))}, - {"key": "by", "name": "排序", "value": self._build_filter_values(groups.get("sort", []))}, - ] - return {"class": classes, "filters": filters} - - def categoryContent(self, tid, pg, filter, extend): - params = { - "area": self._stringify((extend or {}).get("area")), - "sort": self._stringify((extend or {}).get("by") or "hot"), - "year": self._stringify((extend or {}).get("year")), - "dramaType": self._stringify(tid), - "plotType": self._stringify((extend or {}).get("class")), - "contentLabel": "", - "page": int(pg), - "rows": 30, - } - payload = self._request_api("/m-station/drama/drama_filter_search", params, method="POST") or {} - items = [] - for vod in payload.get("data", []) or []: - items.append( - { - "vod_id": self._stringify(vod.get("dramaId") or vod.get("id")), - "vod_name": self._stringify(vod.get("title") or vod.get("name")), - "vod_pic": self._stringify(vod.get("coverUrl") or vod.get("cover")), - "vod_remarks": self._join_values(vod.get("year"), vod.get("subtitle")), - } - ) - return self._page_result(items, pg) - - def _episode_name(self, episode): - title = self._stringify(episode.get("title")).strip() - if title: - return title - text = self._stringify(episode.get("text")).strip() - if text: - return text - number = self._stringify(episode.get("episodeNo")).strip() - return f"第{number}集" if number else "正片" - - def detailContent(self, ids): - items = [] - for raw_id in ids or []: - drama_id = self._stringify(raw_id).strip() - if not drama_id: - continue - payload = self._request_api( - "/m-station/drama/page", - { - "hsdrOpen": "0", - "isAgeLimit": "0", - "dramaId": drama_id, - "quality": "AI4K", - "hevcOpen": "0", - "tria4k": "1", - }, - ) or {} - data = payload.get("data") or {} - info = data.get("dramaInfo") or {} - play_urls = [] - for episode in data.get("episodeList", []) or []: - episode_id = self._stringify(episode.get("sid") or episode.get("id")).strip() - if not episode_id: - continue - play_urls.append(f"{self._episode_name(episode)}${drama_id}@{episode_id}") - items.append( - { - "vod_id": drama_id, - "vod_name": self._stringify(info.get("title")), - "vod_pic": self._stringify(info.get("coverUrl") or info.get("cover") or info.get("cover3Url")), - "vod_remarks": self._stringify(info.get("playStatus")), - "vod_year": self._stringify(info.get("year")), - "vod_area": self._stringify(info.get("area")), - "vod_actor": self._stringify(info.get("actor") or info.get("subtitle")), - "vod_director": self._stringify(info.get("director")), - "vod_content": self._stringify( - info.get("introduction") or info.get("description") or info.get("subtitle") - ), - "type_name": self._stringify(info.get("plotType") or self.class_name_map.get(info.get("dramaType"), "")), - "vod_play_from": "人人专线" if play_urls else "", - "vod_play_url": "#".join(play_urls), - } - ) - return {"list": items} - - def playerContent(self, flag, id, vipFlags): - raw = self._stringify(id).strip() - if "@" not in raw: - return {"parse": 1, "playUrl": "", "url": raw, "jx": 1} - drama_id, episode_sid = raw.split("@", 1) - payload = self._request_api( - "/m-station/drama/play", - { - "dramaId": drama_id, - "episodeSid": episode_sid, - "hevcOpen": "0", - "hsdrOpen": "0", - "quality": "AI4K", - "tria4k": "1", - }, - ) or {} - data = payload.get("data") or {} - encrypted_url = self._stringify((data.get("m3u8") or {}).get("url") or (data.get("tria4kPlayInfo") or {}).get("url")) - final_url = self._decrypt_aes_cbc(encrypted_url, data.get("newSign")) - if not final_url: - return {"parse": 1, "playUrl": "", "url": "", "jx": 1} - try: - response = self.fetch( - final_url, - headers={"User-Agent": UA}, - timeout=10, - verify=False, - allow_redirects=False, - ) - final_url = self._stringify(getattr(response, "headers", {}).get("location") or final_url) - except Exception: - pass - return { - "parse": 0, - "playUrl": "", - "url": final_url, - "jx": 0, - "header": {"User-Agent": UA, "Referer": HOST}, - } - - def searchContent(self, key, quick, pg="1"): - keyword = self._stringify(key).strip() - if not keyword: - return self._page_result([], pg) - payload = self._request_api( - "/search/comprehensive/precise-mixed", - {"keywords": keyword, "size": "20", "searchAfter": ""}, - ) or {} - data = payload.get("data") or {} - source = list(data.get("seasonList") or []) or list(data.get("fuzzySeasonList") or []) - items = [] - seen = set() - for vod in source: - vod_id = self._stringify(vod.get("id") or vod.get("dramaId")) - if not vod_id or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": self._stringify(vod.get("title") or vod.get("name")), - "vod_pic": self._stringify(vod.get("cover") or vod.get("coverUrl")), - "vod_remarks": self._join_values(vod.get("year"), vod.get("classify") or vod.get("cat")), - } - ) - return self._page_result(items, pg) diff --git a/py/人人视频.txt b/py/人人视频.txt new file mode 100644 index 0000000..5ac53ec --- /dev/null +++ b/py/人人视频.txt @@ -0,0 +1,15 @@ +// ignore +//@name:人人视频 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:b+MxQr3D/ijh3zYY +//@ek:base64:yJEs5aUU8AJ1oolaVfQxijNXmxyv/r/VFN9f9hd4B0seP7WyPeptVV/7XhB1qBdI +//@hash:sha256:164fbe139b4b3a4ba209ea1acc8b0ffe1b0ed2fb104c0cb55d23c07351a37100 +//@sig:base64:qEWl+Pn17fiYL1w5bj1HQADZI4tnhqZRPdu/RjkOtSo7S0W5ia+gs5vhn1mKTnYHBsDRqmblquc0hjm+HHdZBg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/低端影视.py b/py/低端影视.py deleted file mode 100644 index df08eaa..0000000 --- a/py/低端影视.py +++ /dev/null @@ -1,369 +0,0 @@ -# coding=utf-8 -import base64 -import json -import re -import sys -from urllib.parse import quote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "低端影视" - self.host = "https://ddys.io" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/145.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "series", "type_name": "剧集"}, - {"type_id": "movie", "type_name": "电影"}, - {"type_id": "variety", "type_name": "综艺"}, - {"type_id": "anime", "type_name": "动漫"}, - ] - common_class_values = [ - {"n": "全部", "v": ""}, - {"n": "动作", "v": "/genre/action"}, - {"n": "喜剧", "v": "/genre/comedy"}, - {"n": "爱情", "v": "/genre/romance"}, - {"n": "科幻", "v": "/genre/scifi"}, - {"n": "悬疑", "v": "/genre/thriller"}, - {"n": "剧情", "v": "/genre/drama"}, - {"n": "恐怖", "v": "/genre/horror"}, - {"n": "惊悚", "v": "/genre/suspense"}, - {"n": "冒险", "v": "/genre/adventure"}, - {"n": "战争", "v": "/genre/war"}, - {"n": "历史", "v": "/genre/history"}, - {"n": "传记", "v": "/genre/biography"}, - {"n": "犯罪", "v": "/genre/crime"}, - {"n": "西部", "v": "/genre/western"}, - {"n": "奇幻", "v": "/genre/fantasy"}, - {"n": "音乐", "v": "/genre/music"}, - {"n": "歌舞", "v": "/genre/musical"}, - {"n": "家庭", "v": "/genre/family"}, - {"n": "运动", "v": "/genre/sport"}, - {"n": "古装", "v": "/genre/costume"}, - {"n": "武侠", "v": "/genre/martial"}, - {"n": "都市", "v": "/genre/urban"}, - {"n": "灾难", "v": "/genre/disaster"}, - {"n": "其他", "v": "/genre/other"}, - ] - common_area_values = [ - {"n": "全部", "v": ""}, - {"n": "中国", "v": "/region/china"}, - {"n": "美国", "v": "/region/usa"}, - {"n": "日本", "v": "/region/japan"}, - {"n": "韩国", "v": "/region/korea"}, - {"n": "英国", "v": "/region/uk"}, - {"n": "法国", "v": "/region/france"}, - {"n": "德国", "v": "/region/germany"}, - {"n": "印度", "v": "/region/india"}, - {"n": "意大利", "v": "/region/italy"}, - {"n": "西班牙", "v": "/region/spain"}, - {"n": "加拿大", "v": "/region/canada"}, - {"n": "澳大利亚", "v": "/region/australia"}, - {"n": "俄罗斯", "v": "/region/russia"}, - {"n": "泰国", "v": "/region/thailand"}, - {"n": "中国香港", "v": "/region/hongkong"}, - {"n": "中国台湾", "v": "/region/taiwan"}, - {"n": "中国澳门", "v": "/region/macau"}, - {"n": "其他", "v": "/region/other"}, - ] - common_year_values = [ - {"n": "全部", "v": ""}, - {"n": "2026", "v": "/year/2026"}, - {"n": "2025", "v": "/year/2025"}, - {"n": "2024", "v": "/year/2024"}, - {"n": "2023", "v": "/year/2023"}, - {"n": "2022", "v": "/year/2022"}, - {"n": "2021", "v": "/year/2021"}, - {"n": "2020", "v": "/year/2020"}, - {"n": "2019", "v": "/year/2019"}, - {"n": "2018", "v": "/year/2018"}, - {"n": "2017", "v": "/year/2017"}, - {"n": "2016", "v": "/year/2016"}, - {"n": "2015", "v": "/year/2015"}, - {"n": "2014", "v": "/year/2014"}, - {"n": "2013", "v": "/year/2013"}, - {"n": "2012", "v": "/year/2012"}, - {"n": "2011", "v": "/year/2011"}, - ] - self.filter_def = { - "movie": {"cateId": "movie"}, - "series": {"cateId": "series"}, - "variety": {"cateId": "variety"}, - "anime": {"cateId": "anime"}, - } - self.filters = { - key: [ - {"key": "class", "name": "剧情", "init": "", "value": list(common_class_values)}, - {"key": "area", "name": "地区", "init": "", "value": list(common_area_values)}, - {"key": "year", "name": "年份", "init": "", "value": list(common_year_values)}, - { - "key": "by", - "name": "排序", - "init": "", - "value": [ - {"n": "时间", "v": ""}, - {"n": "评分", "v": "rating/"}, - {"n": "热门", "v": "popular/"}, - ], - }, - ] - for key in ["movie", "series", "variety", "anime"] - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes, "filters": self.filters} - - def homeVideoContent(self): - return {"list": []} - - def _stringify(self, value): - return "" if value is None else str(value) - - def _normalize_ext(self, extend): - if isinstance(extend, dict): - return extend - if not extend: - return {} - try: - return json.loads(str(extend)) - except Exception: - return {} - - def _build_url(self, path): - raw = self._stringify(path).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - if raw.startswith("/"): - return self.host + raw - return self.host + "/" + raw - - def _extract_site_path_id(self, href): - full = self._build_url(href) - matched = re.search(r"https?://[^/]+/(movie|series|variety|anime)/([^/?#]+)/?$", full) - if not matched: - return "" - return f"{matched.group(1)}/{matched.group(2)}" - - def _build_detail_request_url(self, vod_id): - value = self._stringify(vod_id).strip().strip("/") - return self._build_url(value + "/") if value else "" - - def _build_category_url(self, tid, pg, extend): - values = dict(self.filter_def.get(str(tid), {"cateId": str(tid)})) - values.update(self._normalize_ext(extend)) - path = ( - f"{values.get('by', '')}" - f"{values.get('cateId', tid)}" - f"{values.get('class', '')}" - f"{values.get('area', '')}" - f"{values.get('year', '')}" - f"/page/{int(pg)}" - ) - return self._build_url(path) - - def _request_html(self, path_or_url, method="GET", data=None, headers=None, referer=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - merged_headers = dict(self.headers) - if headers: - merged_headers.update(headers) - merged_headers["Referer"] = referer or self.headers["Referer"] - if method == "POST": - response = self.post(target, data=data, headers=merged_headers, timeout=10) - else: - response = self.fetch(target, headers=merged_headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _parse_movie_cards(self, html, root_xpath="//*[contains(@class,'movie-card')]"): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for node in root.xpath(root_xpath): - href = ((node.xpath(".//a[@href][1]/@href") or [""])[0]).strip() - title = self._clean_text("".join(node.xpath(".//h3[1]//text()"))) - pic = ( - ((node.xpath(".//img[1]/@src") or [""])[0]).strip() - or ((node.xpath(".//img[1]/@data-src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(node.xpath(".//*[contains(@class,'poster-badge')][1]//text()"))) - vod_id = self._extract_site_path_id(href) - if not vod_id or not title or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - items = self._parse_movie_cards(self._request_html(self._build_category_url(tid, pg, extend))) - return { - "list": items, - "page": page, - "limit": 24, - "total": page * 30 + len(items), - } - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._stringify(key).strip() - if not keyword: - return {"page": page, "total": 0, "list": []} - html = self._request_html( - self.host + "/search", - method="POST", - data=f"q={quote(keyword)}", - headers={"Content-Type": "application/x-www-form-urlencoded"}, - ) - items = self._parse_movie_cards( - html, - root_xpath="(//*[contains(@class,'mb-12')])[1]//*[contains(@class,'movie-card')]", - ) - if not items: - items = self._parse_movie_cards(html) - return {"page": page, "total": len(items), "list": items} - - def _extract_switch_sources(self, html): - root = self.html(html) - if root is None: - return [] - groups = [] - for button in root.xpath("//button[contains(@onclick,'switchSource')]"): - onclick = (button.xpath("./@onclick") or [""])[0] - matched = re.search(r"switchSource\(\d+,\s*'([^']*)',\s*'[^']*'\)", onclick, re.S) - if not matched: - continue - name = self._clean_text("".join(button.xpath(".//text()"))) or self.name - payload = self._clean_text(matched.group(1)) - if not payload: - continue - if "$" not in payload: - payload = f"全集${payload}" - groups.append({"from": name, "urls": payload}) - return groups - - def _extract_pan_sources(self, html): - root = self.html(html) - if root is None: - return [] - groups = [] - for panel in root.xpath("//*[contains(@class,'download-type-content')]"): - panel_id = ((panel.xpath("./@id") or [""])[0]).replace("download-type-", "").strip() - if panel_id not in ("quark", "xunlei", "baidu"): - continue - entries = [] - seen_links = set() - for button in panel.xpath(".//button[@onclick]"): - onclick = (button.xpath("./@onclick") or [""])[0] - matched = re.search(r"atob\('([^']+)'\)", onclick) - if not matched: - continue - try: - link = base64.b64decode(matched.group(1)).decode("utf-8").strip() - except Exception: - continue - title = self._clean_text("".join(button.xpath(".//text()"))) or panel_id - if link and link not in seen_links: - seen_links.add(link) - entries.append(f"{title}${link}") - if entries: - groups.append({"from": panel_id, "urls": "#".join(entries)}) - return groups - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - if root is None: - return {"vod_id": vod_id, "vod_name": "", "vod_play_from": "", "vod_play_url": ""} - title = self._clean_text("".join(root.xpath("//h1[1]/text()"))) - pic = ((root.xpath("//img[@alt][1]/@src") or [""])[0]).strip() - meta = self._clean_text("".join(root.xpath("(//*[contains(@class,'text-gray-600')])[1]//text()"))) - parts = [self._clean_text(item) for item in meta.split("·")] if meta else [] - director = "" - actor = "" - for text in root.xpath("//*[contains(@class,'text-gray-700')]"): - joined = self._clean_text("".join(text.xpath(".//text()"))) - if joined.startswith("导演："): - director = joined.split("：", 1)[-1].strip() - if joined.startswith("主演："): - actor = joined.split("：", 1)[-1].strip() - content = "\n".join( - [self._clean_text("".join(node.xpath(".//text()"))) for node in root.xpath("//*[contains(@class,'prose')]//p")] - ).strip() - play_groups = self._extract_switch_sources(html) + self._extract_pan_sources(html) - return { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_content": content, - "vod_remarks": " · ".join([item for item in parts if item]), - "vod_year": parts[0] if len(parts) > 0 else "", - "vod_area": parts[1] if len(parts) > 1 else "", - "vod_class": parts[2] if len(parts) > 2 else "", - "vod_director": director, - "vod_actor": actor, - "vod_play_from": "$$$".join([item["from"] for item in play_groups]), - "vod_play_url": "$$$".join([item["urls"] for item in play_groups]), - } - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = self._stringify(raw_id).strip() - if not vod_id: - continue - request_url = self._build_detail_request_url(vod_id) - if not request_url: - continue - vod = self._parse_detail_page(self._request_html(request_url), vod_id) - result["list"].append(vod) - return result - - def _is_pan_flag(self, flag): - lowered = self._stringify(flag).lower() - return any(token in lowered for token in ["quark", "baidu", "xunlei"]) - - def playerContent(self, flag, id, vipFlags): - target = self._stringify(id).strip() - if self._is_pan_flag(flag): - return {"parse": 0, "jx": 0, "url": target, "header": {}} - return { - "parse": 0, - "jx": 0, - "url": self._build_url(target), - "header": dict(self.headers), - } diff --git a/py/低端影视.txt b/py/低端影视.txt new file mode 100644 index 0000000..f9ca88f --- /dev/null +++ b/py/低端影视.txt @@ -0,0 +1,15 @@ +// ignore +//@name:低端影视 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:TX06OfGhdAKyrsQ7 +//@ek:base64:jHcX4TDx1d0ByRty1EMOK9xiDrwf5oSxE8yb0GP4fWvmWYg/p4+G+G4az9JLcbBh +//@hash:sha256:e2fdae8caa86a49f2238b6a5cf82707d68d193aaa9a4f0b47155dac2d92a1642 +//@sig:base64:x38tMW+DSvNB3iitN1QG6t/DVdgLrIcsW8fuxt4NmWeqqoUt5Oro0xw3MWyFr2ZnnsS4qcR0Diaz914RAknEAA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/修罗.py b/py/修罗.py deleted file mode 100644 index bccc590..0000000 --- a/py/修罗.py +++ /dev/null @@ -1,563 +0,0 @@ -# coding=utf-8 -import gzip -import hashlib -import json -import os -import re -import sys -import time -from urllib.parse import quote, urljoin - -from Crypto.Cipher import AES -from Crypto.Util.Padding import pad - -CURRENT_DIR = os.path.dirname(os.path.abspath(__file__)) -if CURRENT_DIR not in sys.path: - sys.path.append(CURRENT_DIR) -if os.path.dirname(CURRENT_DIR) not in sys.path: - sys.path.append(os.path.dirname(CURRENT_DIR)) - -from base.spider import Spider as BaseSpider - - -class Spider(BaseSpider): - BASE_SITE = "https://v.xlys.ltd.ua/" - HOST = "v.xlys.ltd.ua" - SEARCH_API = "https://www.ymck.pro/API/v2.php?q=" - SEARCH_SIZE = "&size=50" - TARGET_WEBSITE = "哔滴" - UA = ( - "Mozilla/5.0 (X11; Linux aarch64) AppleWebKit/537.36 " - "(KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36" - ) - LOCAL_PROXY_BASE = "http://127.0.0.1:9978/proxy?do=py" - - def __init__(self): - self.name = "修罗" - self.host = "https://www.xlys02.com" - self.origin = self.BASE_SITE - self.url_re = re.compile(r"https?://[^/]+(?P/.*?\.htm)", re.I) - self.classes = [ - {"type_id": "movie", "type_name": "电影"}, - {"type_id": "tv", "type_name": "电视剧"}, - {"type_id": "zongyi", "type_name": "综艺"}, - {"type_id": "duanju", "type_name": "短剧"}, - ] - common_genres = [ - {"n": "不限", "v": "all"}, - {"n": "动作", "v": "dongzuo"}, - {"n": "爱情", "v": "aiqing"}, - {"n": "喜剧", "v": "xiju"}, - {"n": "科幻", "v": "kehuan"}, - {"n": "恐怖", "v": "kongbu"}, - {"n": "战争", "v": "zhanzheng"}, - {"n": "武侠", "v": "wuxia"}, - {"n": "魔幻", "v": "mohuan"}, - {"n": "剧情", "v": "juqing"}, - {"n": "动画", "v": "donghua"}, - {"n": "惊悚", "v": "jingsong"}, - {"n": "灾难", "v": "zainan"}, - {"n": "悬疑", "v": "xuanyi"}, - {"n": "警匪", "v": "jingfei"}, - {"n": "文艺", "v": "wenyi"}, - {"n": "青春", "v": "qingchun"}, - {"n": "冒险", "v": "maoxian"}, - {"n": "犯罪", "v": "fanzui"}, - {"n": "记录", "v": "jilu"}, - {"n": "古装", "v": "guzhuang"}, - {"n": "奇幻", "v": "奇幻"}, - ] - common_areas = [ - {"n": "不限", "v": ""}, - {"n": "中国大陆", "v": "中国大陆"}, - {"n": "中国香港", "v": "中国香港"}, - {"n": "美国", "v": "美国"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - {"n": "法国", "v": "法国"}, - {"n": "印度", "v": "印度"}, - {"n": "德国", "v": "德国"}, - {"n": "西班牙", "v": "西班牙"}, - {"n": "意大利", "v": "意大利"}, - {"n": "澳大利亚", "v": "澳大利亚"}, - {"n": "比利时", "v": "比利时"}, - {"n": "瑞典", "v": "瑞典"}, - {"n": "荷兰", "v": "荷兰"}, - {"n": "丹麦", "v": "丹麦"}, - {"n": "加拿大", "v": "加拿大"}, - {"n": "俄罗斯", "v": "俄罗斯"}, - ] - years = [{"n": "不限", "v": ""}] + [{"n": str(year), "v": str(year)} for year in range(2026, 2001, -1)] - order_values = [{"n": "更新时间", "v": "0"}, {"n": "豆瓣评分", "v": "1"}] - self.filters = { - "movie": [ - {"key": "genre", "name": "类型", "init": "all", "value": list(common_genres)}, - {"key": "area", "name": "地区", "init": "", "value": list(common_areas)}, - {"key": "year", "name": "年份", "init": "", "value": list(years)}, - {"key": "order", "name": "排序", "init": "0", "value": list(order_values)}, - ], - "tv": [ - {"key": "genre", "name": "类型", "init": "all", "value": list(common_genres)}, - {"key": "area", "name": "地区", "init": "", "value": list(common_areas)}, - {"key": "year", "name": "年份", "init": "", "value": list(years)}, - {"key": "order", "name": "排序", "init": "0", "value": list(order_values)}, - ], - "zongyi": [ - {"key": "area", "name": "地区", "init": "", "value": list(common_areas)}, - {"key": "year", "name": "年份", "init": "", "value": list(years)}, - {"key": "order", "name": "排序", "init": "0", "value": list(order_values)}, - ], - "duanju": [ - {"key": "year", "name": "年份", "init": "", "value": [{"n": "不限", "v": ""}] + [{"n": str(year), "v": str(year)} for year in range(2026, 2022, -1)]}, - {"key": "order", "name": "排序", "init": "0", "value": list(order_values)}, - ], - } - self._detail_title_blacklist = {"观看历史", "猜你喜欢", "相关推荐", "相关影视", "热门推荐", "为你推荐"} - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": list(self.classes), "filters": self.filters, "list": []} - - def homeVideoContent(self): - return {"list": []} - - def categoryContent(self, tid, pg, filter, extend): - page = max(int(str(pg or "1")), 1) - type_id = self._stringify(tid).strip() - if type_id not in self.filters: - return {"page": page, "limit": 0, "total": 0, "list": []} - values = extend or {} - if "genre" not in values: - if type_id == "movie": - values["genre"] = "all" - if type_id == "tv": - values["genre"] = "all" - url = self._build_category_url(type_id, page, values) - response = self.fetch(url, headers=self.build_headers(), timeout=15) - if response.status_code != 200: - return {"page": page, "limit": 0, "total": 0, "list": []} - items = self._parse_category_cards(response.text or "") - return {"page": page, "limit": len(items), "total": page * 30 + len(items), "list": items} - - def build_headers(self, extra=None): - headers = { - "User-Agent": self.UA, - "Origin": self.origin, - "Referer": self.origin, - } - if isinstance(extra, dict): - headers.update(extra) - return headers - - def _site_headers(self, referer=None, extra=None): - headers = {"User-Agent": self.UA, "Referer": referer or (self.host + "/")} - if isinstance(extra, dict): - headers.update(extra) - return headers - - def _stringify(self, value): - return "" if value is None else str(value) - - def _build_url(self, value): - raw = self._stringify(value).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw) - - def _extract_vod_path(self, value): - raw = self._stringify(value).strip() - if not raw: - return "" - if raw.startswith("/"): - return "/" + raw.lstrip("/") - matched = self.url_re.search(raw) - if matched: - return "/" + matched.group("path").lstrip("/") - generic = re.search(r"(/[^?#\s]+?\.htm)", raw, re.I) - if generic: - return "/" + generic.group(1).lstrip("/") - return "" - - def _extract_site_id(self, href): - raw = self._stringify(href).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - matched = re.search(r"^https?://[^/]+/(.+?)(?:\.htm|[?#]|$)", raw, re.I) - return matched.group(1).lstrip("/") if matched else "" - cleaned = raw.split(".htm", 1)[0] - return cleaned.lstrip("/") - - def _normalize_detail_id(self, value): - raw = self._stringify(value).strip() - if not raw: - return "" - path = self._extract_vod_path(raw) - if path: - return self._extract_site_id(path) - return self._extract_site_id(raw) - - def _clean_text(self, value): - return re.sub(r"\s+", " ", self._stringify(value).replace("\xa0", " ")).strip() - - def _extract_detail_title(self, root): - if root is None: - return "" - candidate_xpaths = [ - "//*[contains(concat(' ', normalize-space(@class), ' '), ' detail ')]//*[self::h1 or self::h2][1]//text()", - "//*[contains(concat(' ', normalize-space(@class), ' '), ' col ')]//*[self::h1 or self::h2][1]//text()", - "//h1[1]//text()", - "//h2//text()", - ] - for xpath in candidate_xpaths: - nodes = root.xpath(xpath) - if not nodes: - continue - texts = nodes if isinstance(nodes, list) else [nodes] - for text in texts: - title = self._clean_text(text) - if title and title not in self._detail_title_blacklist: - return title - return "" - - def _extract_labeled_meta(self, root): - info = {} - if root is None: - return info - for node in root.xpath("//p[strong[1]]|//li[strong[1]]|//div[strong[1]]"): - label = self._clean_text("".join(node.xpath("./strong[1]//text()"))).rstrip(":：") - if not label: - continue - - link_texts = [] - for text in node.xpath(".//a//text()"): - value = self._clean_text(text) - if value and value not in link_texts: - link_texts.append(value) - - raw_text = self._clean_text("".join(node.xpath(".//text()"))) - raw_text = re.sub(r"^\s*%s\s*[:：]?\s*" % re.escape(label), "", raw_text).strip() - - value = "" - if label in ("导演", "主演", "演员", "编剧", "类型"): - value = " / ".join(link_texts) if link_texts else raw_text - else: - value = raw_text - - if label in ("制片国家/地区", "地区"): - value = value.strip("[]") - - hrefs = [self._stringify(item).strip() for item in node.xpath(".//a/@href") if self._stringify(item).strip()] - info[label] = {"value": value, "hrefs": hrefs, "links": link_texts} - return info - - def _is_media_url(self, value): - return re.search(r"^https?://.+\.(?:m3u8|mp4|flv|mkv|ts)(?:[?#].*)?$", self._stringify(value), re.I) is not None - - def _page_result(self, items, pg): - page = max(int(str(pg or "1")), 1) - return {"page": page, "limit": len(items), "total": (page - 1) * 50 + len(items), "list": items} - - def _build_category_url(self, tid, page, values): - genre = self._stringify((values or {}).get("genre")).strip() or tid - url = f"{self.host}/s/{genre}/{page}" - params = [] - if tid not in ("zongyi", "duanju"): - params.append("type=1" if tid == "tv" else "type=0") - area = self._stringify((values or {}).get("area")).strip() - year = self._stringify((values or {}).get("year")).strip() - order = self._stringify((values or {}).get("order")).strip() - if area: - params.append(f"area={quote(area)}") - if year: - params.append(f"year={year}") - if order: - params.append(f"order={order}") - return url + ("?" + "&".join(params) if params else "") - - def _parse_category_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - for card in root.xpath("//*[contains(concat(' ', normalize-space(@class), ' '), ' card ') and contains(concat(' ', normalize-space(@class), ' '), ' card-link ')]"): - href = self._stringify((card.xpath(".//a[@href][1]/@href") or [""])[0]).strip() - vod_id = self._extract_site_id(href) - if not vod_id: - continue - title = self._stringify("".join(card.xpath(".//*[contains(concat(' ', normalize-space(@class), ' '), ' card-title ')]//text()"))).strip() - pic = self._stringify((card.xpath(".//img[1]/@src") or [""])[0]).strip() - remarks = self._stringify("".join(card.xpath(".//*[contains(concat(' ', normalize-space(@class), ' '), ' text-muted ')]//text()"))).strip() - items.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def searchContent(self, key, quick, pg="1"): - keyword = self._stringify(key).strip() - if not keyword: - return self._page_result([], pg) - url = f"{self.SEARCH_API}{keyword}{self.SEARCH_SIZE}" - response = self.fetch(url, headers=self.build_headers(), timeout=15) - if response.status_code != 200: - return self._page_result([], pg) - try: - payload = response.json() - except Exception: - return self._page_result([], pg) - - items = [] - for row in payload.get("data", []) or []: - if self._stringify((row or {}).get("website")).strip() != self.TARGET_WEBSITE: - continue - vod_id = self._extract_vod_path((row or {}).get("url")) - if not vod_id: - continue - items.append( - { - "vod_id": vod_id, - "vod_name": self._stringify((row or {}).get("text")).strip(), - "vod_pic": self._stringify((row or {}).get("icon")).strip(), - "vod_remarks": self._stringify((row or {}).get("website")).strip(), - } - ) - return self._page_result(items, pg) - - def detailContent(self, ids): - vod_id = self._normalize_detail_id(ids[0] if ids else "") - if not vod_id: - return {"list": []} - detail_url = f"{self.host}/{vod_id}.htm" - response = self.fetch(detail_url, headers=self._site_headers(detail_url), timeout=15) - if response.status_code != 200: - return {"list": []} - root = self.html(response.text or "") - if root is None: - return {"list": []} - play_urls = [] - for anchor in root.xpath("//*[@id='play-list']//a[@href]"): - name = self._stringify("".join(anchor.xpath(".//text()"))).strip() - href = self._stringify((anchor.xpath("./@href") or [""])[0]).strip() - play_id = self._extract_site_id(href) - if name and play_id: - play_urls.append(f"{name}${play_id}") - meta = self._extract_labeled_meta(root) - type_name = self._stringify((meta.get("类型") or {}).get("value")).strip() - douban_meta = meta.get("豆瓣链接") or meta.get("豆瓣ID") or {} - douban_text = self._stringify(douban_meta.get("value")).strip() - douban_id = "" - for href in douban_meta.get("hrefs") or []: - matched = re.search(r"douban\.com/subject/(\d+)", href, re.I) - if matched: - douban_id = matched.group(1) - break - if not douban_id: - matched = re.search(r"\b(\d{5,})\b", douban_text) - if matched: - douban_id = matched.group(1) - score_meta = meta.get("豆瓣评分") or meta.get("豆瓣") or meta.get("评分") or {} - score_text = self._stringify(score_meta.get("value")).strip() - score_match = re.search(r"(\d+(?:\.\d+)?)", score_text) - vod = { - "vod_id": vod_id, - "vod_name": self._extract_detail_title(root), - "vod_pic": self._build_url((root.xpath("//img[contains(concat(' ', normalize-space(@class), ' '), ' cover ')]/@src") or [""])[0]), - "type_name": type_name, - "vod_class": type_name, - "vod_year": self._stringify((meta.get("年代") or meta.get("年份") or {}).get("value")).strip(), - "vod_area": self._stringify((meta.get("制片国家/地区") or meta.get("地区") or {}).get("value")).strip(), - "vod_lang": self._stringify((meta.get("语言") or {}).get("value")).strip(), - "vod_remarks": self._stringify((meta.get("摘要") or {}).get("value")).strip(), - "vod_actor": self._stringify((meta.get("主演") or meta.get("演员") or {}).get("value")).strip(), - "vod_director": self._stringify((meta.get("导演") or {}).get("value")).strip(), - "vod_douban_score": score_match.group(1) if score_match else "", - "vod_douban_id": douban_id, - "vod_content": self._clean_text("".join(root.xpath("//*[@id='synopsis'][1]//text()"))), - "vod_play_from": "修罗直连" if play_urls else "", - "vod_play_url": "#".join(play_urls), - } - return {"list": [vod]} - - def _current_millis(self): - return int(time.time() * 1000) - - def _load_json(self, response): - if response is None: - return {} - try: - return response.json() - except Exception: - try: - return json.loads(self._stringify(getattr(response, "text", "")) or "{}") - except Exception: - return {} - - def _build_play_page_url(self, value): - raw = self._stringify(value).strip() - if not raw: - return "" - if self._is_media_url(raw): - return raw - if raw.startswith(("http://", "https://")): - return raw - return f"{self.host}/{self._extract_site_id(raw)}.htm" - - def _extract_pid(self, html): - matched = re.search(r"var\s+pid\s*=\s*(\d+)\s*;", self._stringify(html)) - return self._stringify(matched.group(1) if matched else "").strip() - - def _build_lines_signature(self, pid, millis): - payload = f"{pid}-{millis}" - key = hashlib.md5(payload.encode("utf-8")).hexdigest()[:16] - return self._aes_ecb_hex(key, payload).upper() - - def _pick_direct_urls(self, data): - urls = [] - for item in self._stringify((data or {}).get("url3")).split(","): - url = self._stringify(item).strip() - if not url: - continue - lower = url.lower() - if ".m3u8" in lower or "byteimg" in lower: - continue - urls.append(url) - return urls - - def _request_tos_url(self, pid, millis, sg, play_page_url): - target = f"{self.host}/god/{pid}?type=1" - response = self.post( - target, - data=f"t={millis}&sg={sg}&verifyCode=888", - headers=self._site_headers(play_page_url), - timeout=15, - ) - data = self._load_json(response) - url = self._stringify((data or {}).get("url")).strip() - if not url: - return "" - lower = url.lower() - if ".m3u8" in lower or "byteimg" in lower: - return "" - return url - - def _range_probe(self, url): - return self.fetch( - url, - headers=self.build_headers({"Range": "bytes=0-0"}), - timeout=20, - stream=True, - ) - - def _make_proxy_url(self, real_url): - return f"{self.LOCAL_PROXY_BASE}&type=m3u8&url={quote(self._stringify(real_url).strip(), safe='')}" - - def _aes_ecb_hex(self, key, data): - cipher = AES.new(str(key).encode("utf-8"), AES.MODE_ECB) - return cipher.encrypt(pad(self._stringify(data).encode("utf-8"), 16)).hex() - - def _decode_m3u8_payload(self, payload): - return gzip.decompress(payload[3354:]).decode("utf-8") - - def _rewrite_m3u8(self, text, real_url): - lines = [] - for raw_line in self._stringify(text).splitlines(): - line = raw_line.strip() - if not line or line.startswith("#"): - lines.append(raw_line) - continue - target = line if line.startswith(("http://", "https://")) else urljoin(real_url, line) - lines.append(self._make_proxy_url(target)) - return "\n".join(lines) - - def playerContent(self, flag, id, vipFlags): - raw = self._stringify(id).strip() - if not raw: - return {"parse": 1, "jx": 1, "playUrl": "", "url": "", "header": self.build_headers()} - - if not self._is_media_url(raw): - play_page_url = self._build_play_page_url(raw) - response = self.fetch(play_page_url, headers=self._site_headers(play_page_url), timeout=15) - html = response.text if response.status_code == 200 else "" - pid = self._extract_pid(html) - if not pid: - return {"parse": 1, "jx": 1, "playUrl": "", "url": play_page_url, "header": self._site_headers(play_page_url)} - - millis = self._current_millis() - sg = self._build_lines_signature(pid, millis) - lines_url = f"{self.host}/lines?t={millis}&sg={sg}&pid={pid}" - lines_response = self.fetch( - lines_url, - headers=self._site_headers(play_page_url, {"X-Requested-With": "XMLHttpRequest"}), - timeout=15, - ) - payload = self._load_json(lines_response) - data = (payload or {}).get("data") or {} - if int((payload or {}).get("code", 0)) == 0: - direct_urls = self._pick_direct_urls(data) - if direct_urls: - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": direct_urls[0], - "header": {"User-Agent": self.UA, "Referer": self.host}, - } - if data.get("tos"): - tos_url = self._request_tos_url(pid, millis, sg, play_page_url) - if tos_url: - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": tos_url, - "header": {"User-Agent": self.UA, "Referer": self.host}, - } - return {"parse": 1, "jx": 1, "playUrl": "", "url": play_page_url, "header": self._site_headers(play_page_url)} - - if re.search(r"\.mp4(?:[?#]|$)", raw, re.I): - try: - response = self._range_probe(raw) - if "video/mp4" in self._stringify(response.headers.get("Content-Type")).lower(): - return {"parse": 0, "jx": 0, "playUrl": "", "url": raw, "header": self.build_headers()} - except Exception: - return {"parse": 0, "jx": 0, "playUrl": "", "url": raw, "header": self.build_headers()} - - return {"parse": 0, "jx": 0, "playUrl": "", "url": self._make_proxy_url(raw), "header": self.build_headers()} - - def localProxy(self, params): - if not isinstance(params, dict): - return None - if self._stringify(params.get("type")).strip().lower() != "m3u8": - return None - real_url = self._stringify(params.get("url")).strip() - if not real_url: - return None - - response = self.fetch(real_url, headers=self.build_headers(), timeout=20) - if response.status_code != 200: - return [response.status_code, "text/plain", b""] - rewritten = self._rewrite_m3u8(self._decode_m3u8_payload(response.content), real_url) - return [200, "application/vnd.apple.mpegurl", rewritten.encode("utf-8")] - - def isVideoFormat(self, url): - return self._is_media_url(url) - - def manualVideoCheck(self): - return False diff --git a/py/修罗.txt b/py/修罗.txt new file mode 100644 index 0000000..4a8512e --- /dev/null +++ b/py/修罗.txt @@ -0,0 +1,15 @@ +// ignore +//@name:修罗 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:3tQ6te2itoQhGolI +//@ek:base64:be/pJHtf7T0u6SIAzYzhJKmNyLraXAl8mhx4e5KB8+rG0xQlrngSI5fhVc8J4I3f +//@hash:sha256:f9b2aa8e20e5fcae0a45f056cf8c1dc7b778d898f6d21315b40ff2913c09f968 +//@sig:base64:bZPUhNySw9sMTpXH2t5amjjekDrEsFjd+Xr+5G/RcdanXrVG7e0gXkblffMCzRMF2IlgKQEGMuhyJT8mwbgsDQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/凡客TV.py b/py/凡客TV.py deleted file mode 100644 index 68b9fd4..0000000 --- a/py/凡客TV.py +++ /dev/null @@ -1,378 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "凡客TV" - self.host = "https://fktv.me" - self.cookie = "_did=57nTmEknMZ146xw4KXGHDCHk1MjshRyY" - self.user_agent = ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0" - ) - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "剧集"}, - {"type_id": "4", "type_name": "动漫"}, - {"type_id": "3", "type_name": "综艺"}, - {"type_id": "8", "type_name": "短剧"}, - {"type_id": "6", "type_name": "纪录片"}, - {"type_id": "7", "type_name": "解说"}, - {"type_id": "5", "type_name": "音乐"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - return {"list": []} - - def _clean_text(self, value): - return re.sub(r"\s+", " ", str(value or "").replace("\xa0", " ")).strip() - - def _abs_url(self, value): - raw = str(value or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw) - - def _page_headers(self, referer=""): - headers = {"User-Agent": self.user_agent, "Referer": referer or self.host + "/"} - if self.cookie: - headers["Cookie"] = self.cookie - return headers - - def _request_html(self, url, headers=None): - response = self.fetch(url, headers=headers or self._page_headers(), timeout=10, verify=False) - if response.status_code != 200: - return "" - return str(response.text or "") - - def _ajax_headers(self, referer): - headers = { - "User-Agent": self.user_agent, - "Referer": referer, - "Origin": self.host, - "X-Requested-With": "XMLHttpRequest", - "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", - } - if self.cookie: - headers["Cookie"] = self.cookie - return headers - - def _request_json(self, url, data=None, headers=None): - response = self.post( - url, - data=data, - headers=headers or self._ajax_headers(self.host + "/"), - timeout=10, - verify=False, - ) - if response.status_code != 200: - return {} - try: - return json.loads(str(response.text or "")) - except Exception: - return {} - - def _extract_cards(self, html): - root = self.html(html or "") - if root is None: - return [] - items = [] - seen = set() - nodes = root.xpath("//*[contains(@class,'meta-wrap')]/.. | //*[contains(@class,'hover-wrap')]") - for node in nodes: - href = self._clean_text( - "".join( - node.xpath( - ".//a[contains(@class,'normal-title') or contains(@class,'hover-title')][1]/@href" - ) - ) - ) - matched = re.search(r"/movie/detail/([0-9A-Za-z]+)", href) - if not matched: - continue - vod_id = matched.group(1) - if vod_id in seen: - continue - seen.add(vod_id) - title = self._clean_text( - "".join( - node.xpath( - ".//a[contains(@class,'normal-title') or contains(@class,'hover-title')][1]/@title" - ) - ) - ) or self._clean_text( - "".join( - node.xpath( - ".//a[contains(@class,'normal-title') or contains(@class,'hover-title')][1]//text()" - ) - ) - ) - pic = self._clean_text("".join(node.xpath(".//*[contains(@class,'lazy-load')][1]/@data-src"))) - tags = [ - self._clean_text("".join(tag.xpath(".//text()"))) - for tag in node.xpath(".//*[contains(@class,'tag')]") - ] - tags = [tag for tag in tags if tag] - if not title: - continue - items.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._abs_url(pic), - "vod_remarks": " | ".join(tags), - "type_name": tags[0] if tags else "", - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = max(1, int(pg)) - url = self.host + f"/channel?page={page}&cat_id={tid}&page_size=32&order=new" - items = self._extract_cards(self._request_html(url)) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = max(1, int(pg)) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "limit": 0, "total": 0, "list": []} - url = self.host + "/search?keyword=" + quote(keyword) - items = self._extract_cards(self._request_html(url)) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def _safe_json_loads(self, value, fallback=None): - try: - data = json.loads(str(value or "")) - except Exception: - data = fallback - return data if data is not None else fallback - - def _extract_page_state(self, html): - body = str(html or "") - state = {"movieId": "", "linkId": "", "links": [], "play_links": [], "play_error_type": ""} - movie = re.search(r"let\s+movieId\s*=\s*['\"]([^'\"]+)['\"]", body) - link = re.search(r"let\s+linkId\s*=\s*['\"]([^'\"]+)['\"]", body) - links = re.search(r"var\s+links\s*=\s*(\[[\s\S]*?\]);", body) - play_links = re.search(r"var\s+play_links\s*=\s*(\[[\s\S]*?\]);", body) - error_type = re.search(r"var\s+play_error_type\s*=\s*['\"]([^'\"]*)['\"]", body) - if movie: - state["movieId"] = movie.group(1) - if link: - state["linkId"] = link.group(1) - if links: - state["links"] = self._safe_json_loads(links.group(1), []) or [] - if play_links: - state["play_links"] = self._safe_json_loads(play_links.group(1), []) or [] - if error_type: - state["play_error_type"] = error_type.group(1) - return state - - def _extract_line_tabs(self, html): - root = self.html(html or "") - if root is None: - return [] - lines = [] - seen = set() - for node in root.xpath("//*[contains(@class,'item-wrap')][@data-line]"): - line_id = self._clean_text("".join(node.xpath("./@data-line"))) - name = self._clean_text("".join(node.xpath(".//text()"))) - if not line_id or line_id in seen: - continue - seen.add(line_id) - lines.append({"id": line_id, "name": name or line_id}) - return lines - - def _pick_episode_name(self, item): - for key in ("name", "title", "id"): - value = self._clean_text((item or {}).get(key)) - if value: - return value - return "正片" - - def detailContent(self, ids): - vod_id = str(ids[0] if isinstance(ids, list) and ids else ids or "").strip() - if not vod_id: - return {"list": []} - page_url = self.host + "/movie/detail/" + vod_id - html = self._request_html(page_url, self._page_headers(self.host + "/")) - root = self.html(html or "") - state = self._extract_page_state(html) - title = "" - pic = "" - content = "" - if root is not None: - title = self._clean_text("".join(root.xpath("//h1[1]//text()"))) - if not title: - title = self._clean_text("".join(root.xpath("//title[1]//text()"))) - title = title.replace("-免费在线观看-凡客影视", "").strip() - pic = self._clean_text("".join(root.xpath("//meta[@property='og:image'][1]/@content"))) - if not pic: - pic = self._clean_text("".join(root.xpath("//video[1]/@poster"))) - content = self._clean_text("".join(root.xpath("//meta[@name='description'][1]/@content"))) - - lines = self._extract_line_tabs(html) - if not lines: - lines = [] - for item in state["play_links"]: - line_id = str((item or {}).get("id") or "").strip() - if not line_id: - continue - lines.append( - { - "id": line_id, - "name": self._clean_text((item or {}).get("name")) or line_id, - } - ) - - groups = [] - for line in lines: - entries = [] - for episode in state["links"]: - link_id = str((episode or {}).get("id") or "").strip() - if not link_id: - continue - meta = { - "movie_id": state["movieId"] or vod_id, - "link_id": link_id, - "line_id": line["id"], - "line_name": line["name"], - "episode_name": self._pick_episode_name(episode), - "type": "switch", - "page": page_url, - } - entries.append(meta["episode_name"] + "$" + self._encode_play_id(meta)) - if entries: - groups.append((line["name"], "#".join(entries))) - - remarks = [] - if state["play_error_type"] == "captcha": - remarks.append("站点当前需要验证码") - if state["play_error_type"] == "need_vip": - remarks.append("站点当前存在 VIP 限制") - - return { - "list": [ - { - "vod_id": state["movieId"] or vod_id, - "vod_name": title or vod_id, - "vod_pic": self._abs_url(pic), - "vod_content": content, - "vod_remarks": " | ".join(remarks), - "vod_play_from": "$$$".join(name for name, _ in groups), - "vod_play_url": "$$$".join(urls for _, urls in groups), - } - ] - } - - def _normalize_play_links(self, items): - results = [] - for item in items or []: - raw_url = str((item or {}).get("m3u8_url") or (item or {}).get("preview_m3u8_url") or "").strip() - if not raw_url: - continue - results.append( - { - "line_id": str((item or {}).get("id") or "").strip(), - "name": self._clean_text((item or {}).get("name")) or str((item or {}).get("id") or "线路"), - "url": urljoin(self.host + "/", raw_url), - } - ) - return results - - def _build_player_headers(self, referer, with_origin=False): - headers = {"User-Agent": self.user_agent, "Referer": referer} - if with_origin: - headers["Origin"] = self.host - return headers - - def _build_direct_result(self, entries, referer): - return { - "parse": 0, - "playUrl": "", - "url": entries[0]["url"] if entries else "", - "urls": [{"name": item["name"], "url": item["url"]} for item in entries], - "header": self._build_player_headers(referer, with_origin=True), - } - - def _build_parse_result(self, url): - return { - "parse": 1, - "playUrl": "", - "url": url, - "header": self._build_player_headers(url), - } - - def playerContent(self, flag, id, vipFlags): - raw = str(id or "").strip() - if not raw: - return {"parse": 0, "playUrl": "", "url": "", "header": {}} - if re.search(r"\.(m3u8|mp4|flv)(?:\?|#|$)", raw, re.I): - return { - "parse": 0, - "playUrl": "", - "url": raw, - "header": self._build_player_headers(self.host + "/", with_origin=True), - } - - meta = self._decode_play_id(raw) - page_url = str(meta.get("page") or "").strip() - if not page_url: - movie_id = str(meta.get("movie_id") or "").strip() - page_url = self.host + "/movie/detail/" + movie_id if movie_id else self.host + "/" - - html = self._request_html(page_url, self._page_headers(self.host + "/")) - state = self._extract_page_state(html) - movie_id = str(meta.get("movie_id") or state.get("movieId") or "").strip() - link_id = str(meta.get("link_id") or state.get("linkId") or "").strip() - line_id = str(meta.get("line_id") or "").strip() - - if movie_id and link_id: - payload = self._request_json( - self.host + "/movie/detail/" + movie_id, - data={"link_id": link_id, "is_switch": 1}, - headers=self._ajax_headers(page_url), - ) - data = (payload or {}).get("data") or {} - urls = self._normalize_play_links(data.get("play_links") or []) - if line_id: - urls = [item for item in urls if item["line_id"] == line_id] - if urls: - return self._build_direct_result(urls, page_url) - - return self._build_parse_result(page_url) - - def _encode_play_id(self, payload): - return json.dumps(payload, ensure_ascii=False, separators=(",", ":")) - - def _decode_play_id(self, value): - try: - decoded = json.loads(str(value or "").strip()) - except Exception: - decoded = {} - return decoded if isinstance(decoded, dict) else {} diff --git a/py/凡客TV.txt b/py/凡客TV.txt new file mode 100644 index 0000000..e28dcda --- /dev/null +++ b/py/凡客TV.txt @@ -0,0 +1,15 @@ +// ignore +//@name:凡客TV +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:CkdZARXxOnanlb8j +//@ek:base64:bAy8pqWqOZph+osaENJxJdvuIRvrb3shexJ0P3jclVP+gMhvr1ZoCaIbn9dKMfUh +//@hash:sha256:2952ff6a13080caf57a53afabde305de1eede49825836a535972c032cfdd7197 +//@sig:base64:4O2DHfQM17yqjn6XyN4GhbqiXKkzTX7rROf2Svr4P7c9QroMU5XXZvzWKJ63AgfSjcOul03mhhg2TRKnqeNvBw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/剧圈圈.py b/py/剧圈圈.py deleted file mode 100644 index 22b247e..0000000 --- a/py/剧圈圈.py +++ /dev/null @@ -1,432 +0,0 @@ -# coding=utf-8 -import base64 -import hashlib -import json -import re -import subprocess -import sys -from urllib.parse import quote, unquote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "剧圈圈" - self.host = "https://www.jqqzx.cc" - self._category_vodshow_unavailable = True - self.headers = { - "User-Agent": "Mozilla/5.0", - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - "Referer": self.host + "/", - } - self.categories = [ - {"type_id": "dianying", "type_name": "电影"}, - {"type_id": "juji", "type_name": "剧集"}, - {"type_id": "dongman", "type_name": "动漫"}, - {"type_id": "zongyi", "type_name": "综艺"}, - {"type_id": "duanju", "type_name": "短剧"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", str(text or ""))).strip() - - def _encode_vod_id(self, href): - matched = re.search(r"/vod/([^/?#]+)\.html", self._build_url(href)) - return f"vod/{matched.group(1)}" if matched else "" - - def _decode_vod_id(self, vod_id): - matched = re.search(r"^vod/([^/?#]+)$", str(vod_id or "").strip()) - return self._build_url(f"/vod/{matched.group(1)}.html") if matched else "" - - def _encode_play_id(self, href): - matched = re.search(r"/play/([^/?#]+)\.html", self._build_url(href)) - return f"play/{matched.group(1)}" if matched else "" - - def _decode_play_id(self, play_id): - matched = re.search(r"^play/([^/?#]+)$", str(play_id or "").strip()) - return self._build_url(f"/play/{matched.group(1)}.html") if matched else "" - - def _parse_search_list(self, payload): - try: - data = json.loads(str(payload or "{}")) - except Exception: - return [] - items = [] - for item in data.get("list", []): - item_id = self._clean_text(item.get("id")) - item_name = self._clean_text(item.get("name")) - if not item_id or not item_name: - continue - items.append( - { - "vod_id": f"vod/{item_id}", - "vod_name": item_name, - "vod_pic": self._build_url(item.get("pic")), - "vod_remarks": "", - } - ) - return items - - def _request_html(self, path_or_url, headers=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - request_headers = dict(self.headers) - if headers: - request_headers.update(headers) - response = self.fetch(target, headers=request_headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for anchor in root.xpath("//a[contains(@class,'module-poster-item') and contains(@class,'module-item')]"): - vod_id = self._encode_vod_id((anchor.xpath("./@href") or [""])[0]) - if not vod_id or vod_id in seen: - continue - title = self._clean_text( - "".join(anchor.xpath(".//*[contains(@class,'module-poster-item-title')][1]//text()")) - or (anchor.xpath("./@title") or [""])[0] - or (anchor.xpath(".//img[1]/@alt") or [""])[0] - ) - if not title: - continue - seen.add(vod_id) - pic = ( - anchor.xpath(".//img[1]/@data-original") - or anchor.xpath(".//img[1]/@src") - or [""] - )[0] - note = self._clean_text("".join(anchor.xpath(".//*[contains(@class,'module-item-note')][1]//text()"))) - items.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": note, - } - ) - return items - - def homeVideoContent(self): - return {"list": self._parse_cards(self._request_html(self.host))[:40]} - - def _build_vodshow_category_url(self, tid, page): - if page <= 1: - return self._build_url(f"/vodshow/id/{tid}.html") - return self._build_url(f"/vodshow/id/{tid}/page/{page}.html") - - def _build_type_category_url(self, tid, page): - return self._build_url(f"/type/{tid}/page/{page}.html") - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - items = [] - if not self._category_vodshow_unavailable: - items = self._parse_cards(self._request_html(self._build_vodshow_category_url(tid, page))) - if not items: - self._category_vodshow_unavailable = True - if not items: - items = self._parse_cards(self._request_html(self._build_type_category_url(tid, page))) - return { - "page": page, - "total": len(items), - "list": items, - } - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - items = self._parse_search_list( - self._request_html(self._build_url(f"/index.php/ajax/suggest?mid=1&wd={quote(keyword)}")) - ) - return {"page": page, "total": len(items), "list": items} - - def _parse_info_items(self, root): - info = {} - for item in root.xpath("//*[contains(@class,'module-info-item')]"): - title = self._clean_text( - "".join(item.xpath(".//*[contains(@class,'module-info-item-title')][1]//text()")) - ).rstrip("：:") - if not title: - continue - links = [ - self._clean_text("".join(node.xpath(".//text()"))) - for node in item.xpath(".//*[contains(@class,'module-info-item-content')][1]//a") - ] - links = [value for value in links if value] - if links: - info[title] = " / ".join(links) - continue - info[title] = self._clean_text( - "".join(item.xpath(".//*[contains(@class,'module-info-item-content')][1]//text()")) - ) - return info - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - if root is None: - return {"list": []} - info = self._parse_info_items(root) - tab_names = [] - for node in root.xpath("//*[@id='y-playList']//*[contains(@class,'module-tab-item')]"): - tab_names.append( - self._clean_text( - (node.xpath("./@data-dropdown-value") or [""])[0] - or "".join(node.xpath(".//span[1]//text()")) - or "".join(node.xpath(".//text()")) - ) - ) - groups = [] - for index, box in enumerate(root.xpath("//*[contains(@class,'his-tab-list')]")): - episodes = [] - for anchor in box.xpath(".//a[contains(@class,'module-play-list-link') and @href]"): - play_id = self._encode_play_id((anchor.xpath("./@href") or [""])[0]) - ep_name = self._clean_text( - "".join(anchor.xpath(".//span[1]//text()")) or "".join(anchor.xpath(".//text()")) - ) - if play_id and ep_name: - episodes.append(f"{ep_name}${play_id}") - if episodes: - groups.append( - { - "from": tab_names[index] if index < len(tab_names) and tab_names[index] else f"线路{index + 1}", - "urls": "#".join(episodes), - } - ) - type_name = " / ".join( - [ - self._clean_text("".join(node.xpath(".//text()"))) - for node in root.xpath("//*[contains(@class,'module-info-tag-link')]//a") - if self._clean_text("".join(node.xpath(".//text()"))) - ] - ) - pic = ( - root.xpath( - "(//*[contains(@class,'module-item-pic')]//img/@data-original | " - "//*[contains(@class,'module-info-poster')]//img/@data-original | " - "//*[contains(@class,'module-item-pic')]//img/@src | " - "//*[contains(@class,'module-info-poster')]//img/@src)[1]" - ) - or [""] - )[0] - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": self._clean_text( - "".join(root.xpath("//*[contains(@class,'module-info-heading')]//h1[1]//text()")) - ), - "vod_pic": self._build_url(pic), - "type_name": type_name, - "vod_remarks": info.get("备注") or info.get("状态", ""), - "vod_actor": info.get("主演", ""), - "vod_director": info.get("导演", ""), - "vod_content": self._clean_text( - "".join(root.xpath("//*[contains(@class,'module-info-introduction-content')][1]//text()")) - ), - "vod_play_from": "$$$".join(group["from"] for group in groups), - "vod_play_url": "$$$".join(group["urls"] for group in groups), - } - ] - } - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail_url = self._decode_vod_id(vod_id) - if not detail_url: - continue - parsed = self._parse_detail_page(self._request_html(detail_url), vod_id) - result["list"].extend(parsed.get("list", [])) - return result - - def _request_with_headers(self, path_or_url, headers=None, data=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - request_headers = dict(self.headers) - if headers: - request_headers.update(headers) - try: - if data is None: - response = self.fetch(target, headers=request_headers, timeout=10) - else: - response = self.post(target, data=data, headers=request_headers, timeout=10) - return { - "body": response.text or "", - "headers": getattr(response, "headers", {}) or {}, - "status_code": response.status_code, - } - except Exception: - return self._curl_request(target, headers=request_headers, data=data) - - def _curl_request(self, url, headers=None, data=None): - command = ["curl", "-L", "--silent", "--show-error", "-D", "-", url] - for key, value in (headers or {}).items(): - command.extend(["-H", f"{key}: {value}"]) - if data is not None: - command.extend(["-X", "POST", "--data", data]) - completed = subprocess.run(command, capture_output=True, text=True, check=True, timeout=20) - raw = completed.stdout or "" - marker = "\r\n\r\n" if "\r\n\r\n" in raw else "\n\n" - chunks = [chunk for chunk in raw.split(marker) if chunk.strip()] - header_block = "" - body = "" - for index, chunk in enumerate(chunks): - if chunk.lstrip().startswith("HTTP/"): - header_block = chunk - body = marker.join(chunks[index + 1:]) if index + 1 < len(chunks) else "" - if not header_block and chunks: - header_block = chunks[0] - body = marker.join(chunks[1:]) if len(chunks) > 1 else "" - header_lines = header_block.splitlines() - status_line = header_lines[0] if header_lines else "" - matched = re.search(r"HTTP/\S+\s+(\d+)", status_line) - status_code = int(matched.group(1)) if matched else 200 - parsed_headers = {} - for line in header_lines[1:]: - if ":" not in line: - continue - key, value = line.split(":", 1) - low_key = key.strip().lower() - clean_value = value.strip() - existing = parsed_headers.get(low_key) - if existing is None: - parsed_headers[low_key] = clean_value - elif isinstance(existing, list): - existing.append(clean_value) - else: - parsed_headers[low_key] = [existing, clean_value] - return {"body": body, "headers": parsed_headers, "status_code": status_code} - - def _get_set_cookies(self, headers): - raw = headers.get("set-cookie") or headers.get("Set-Cookie") or [] - items = raw if isinstance(raw, list) else [raw] - return [str(item).split(";", 1)[0] for item in items if str(item).strip()] - - def _merge_cookies(self, *groups): - values = {} - for group in groups: - items = group if isinstance(group, list) else [group] - for item in items: - text = str(item or "").strip() - if "=" not in text: - continue - key, val = text.split("=", 1) - values[key] = val - return [f"{key}={val}" for key, val in values.items()] - - def _base64_decode(self, value): - text = re.sub(r"\s+", "", str(value or "")) - if not text: - return "" - text += "=" * ((4 - len(text) % 4) % 4) - try: - return base64.b64decode(text).decode("utf-8") - except Exception: - return "" - - def _decode_url(self, value): - raw = str(value or "").replace("error://apiRes_", "").strip() - if not raw: - return "" - key = hashlib.md5("test".encode("utf-8")).hexdigest() - first = self._base64_decode(raw) - mixed = "".join(chr(ord(ch) ^ ord(key[index % len(key)])) for index, ch in enumerate(first)) - decoded = self._base64_decode(mixed) - parts = decoded.split("/") - if len(parts) < 3: - return "" - try: - from_map = json.loads(self._base64_decode(parts[1])) - to_map = json.loads(self._base64_decode(parts[0])) - except Exception: - return "" - body = self._base64_decode("/".join(parts[2:])) - mapped = re.sub( - r"[a-zA-Z]", - lambda match: to_map[from_map.index(match.group(0))] - if match.group(0) in from_map and from_map.index(match.group(0)) < len(to_map) - else match.group(0), - body, - ) - matched = re.search(r"https?://[^\s'\"<>]+", mapped) - return matched.group(0) if matched else mapped.strip() - - def _extract_player_data(self, html): - matched = re.search(r"player_aaaa\s*=\s*(\{[\s\S]*?\})\s*;?\s*", str(html or ""), re.I) - if not matched: - return None - try: - return json.loads(matched.group(1)) - except Exception: - return None - - def _is_media_url(self, value): - return bool(re.search(r"^https?://.*\.(m3u8|mp4|flv|m4s)(\?.*)?$", str(value or ""), re.I)) - - def playerContent(self, flag, id, vipFlags): - play_url = self._decode_play_id(id) - if not play_url: - return {"parse": 1, "jx": 1, "url": "", "header": dict(self.headers)} - try: - play_res = self._request_with_headers(play_url, headers={"Referer": self.host + "/"}) - player = self._extract_player_data(play_res["body"]) - if not player: - return {"parse": 1, "jx": 1, "url": play_url, "header": dict(self.headers)} - vid = unquote(str(player.get("url") or "")).strip() - if vid and not self._is_media_url(vid): - decoded = self._decode_url(vid) - if decoded.startswith("http"): - vid = decoded - if self._is_media_url(vid): - return {"parse": 0, "jx": 0, "url": vid, "header": {**self.headers, "Referer": play_url}} - cookies = self._get_set_cookies(play_res["headers"]) - player_page = self._build_url(f"/jx/player.php?vid={quote(vid)}") - player_res = self._request_with_headers( - player_page, - headers={"Referer": play_url, **({"Cookie": "; ".join(cookies)} if cookies else {})}, - ) - cookies = self._merge_cookies(cookies, self._get_set_cookies(player_res["headers"])) - api_res = self._request_with_headers( - self._build_url("/jx/api.php"), - headers={ - "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", - "Accept": "*/*", - "Referer": player_page, - "Origin": self.host, - "X-Requested-With": "XMLHttpRequest", - **({"Cookie": "; ".join(cookies)} if cookies else {}), - }, - data=f"vid={quote(vid)}", - ) - payload = json.loads(api_res["body"] or "{}") - real_url = self._decode_url(payload.get("data", {}).get("url")) - if real_url.startswith("http"): - return {"parse": 0, "jx": 0, "url": real_url, "header": {**self.headers, "Referer": player_page}} - return {"parse": 1, "jx": 1, "url": play_url, "header": {**self.headers, "Referer": player_page}} - except Exception: - return {"parse": 1, "jx": 1, "url": play_url, "header": dict(self.headers)} diff --git a/py/剧圈圈.txt b/py/剧圈圈.txt new file mode 100644 index 0000000..6d359a7 --- /dev/null +++ b/py/剧圈圈.txt @@ -0,0 +1,15 @@ +// ignore +//@name:剧圈圈 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:o/Zz30cK+r48iLwd +//@ek:base64:83P8LlrZxqSA4ucYTYnVdgMg7CEzeDCmieQ0gOP4tf6EhGRCO3YC9egntmfaTZVJ +//@hash:sha256:65903855c5e48127bf762ef42c75884ace053844498bcd6ba9aceacd0da69a23 +//@sig:base64:NqGZRQ+8TryP+5TSMry06rT1nGTIIAWv3HItH8yvoKGSnEFhTvwWQRAh42maAtzB+se4VLI1KaQCPfVhwInTAg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/剧迷.py b/py/剧迷.py deleted file mode 100644 index ea434ff..0000000 --- a/py/剧迷.py +++ /dev/null @@ -1,430 +0,0 @@ -# coding=utf-8 -import base64 -import json -import re -import sys -from urllib.parse import quote, unquote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "Gimy剧迷" - self.host = "https://gimyai.tw" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/146.0.0.0 Safari/537.36" - ), - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - "Referer": "https://gimyai.tw/", - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", - } - self.categories = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "电视剧"}, - {"type_id": "4", "type_name": "动漫"}, - {"type_id": "29", "type_name": "综艺"}, - {"type_id": "34", "type_name": "短剧"}, - {"type_id": "13", "type_name": "陆剧"}, - ] - filter_value = [ - {"n": "最新", "v": "time"}, - {"n": "人气", "v": "hits"}, - {"n": "评分", "v": "score"}, - ] - self.filters = { - key: [{"key": "by", "name": "排序", "init": "time", "value": filter_value}] - for key in ["1", "2", "4", "29", "34", "13"] - } - self.filter_def = {key: {"by": "time"} for key in self.filters} - self.t2s_map = { - "鬥": "斗", - "羅": "罗", - "陸": "陆", - "劇": "剧", - "藝": "艺", - "綜": "综", - "動": "动", - "畫": "画", - "機": "机", - "戰": "战", - "鋼": "钢", - "彈": "弹", - "雲": "云", - "狀": "状", - "態": "态", - "類": "类", - "國": "国", - "導": "导", - "簡": "简", - "線": "线", - "賊": "贼", - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.categories, "filters": self.filters} - - def _build_url(self, href): - raw = str(href or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return self.host + "/" + raw.lstrip("/") - - def _normalize_text(self, text): - value = re.sub(r"<[^>]+>", " ", str(text or "")) - return re.sub(r"\s+", " ", value.replace(" ", " ")).strip() - - def _to_display_text(self, text): - clean = self._normalize_text(text) - for trad, simp in self.t2s_map.items(): - clean = clean.replace(trad, simp) - return clean - - def _extract_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for anchor in root.xpath("//a[contains(@href,'/detail/')]"): - href = (anchor.xpath("./@href") or [""])[0].strip() - matched = re.search(r"/detail/(\d+)\.html", href) - if not matched: - continue - - vod_id = matched.group(1) - if vod_id in seen: - continue - - title = ( - (anchor.xpath("./@title") or [""])[0].strip() - or (anchor.xpath(".//img/@alt") or [""])[0].strip() - or "".join(anchor.xpath(".//text()")).strip() - ) - pic = ( - (anchor.xpath("./@data-original") or [""])[0].strip() - or (anchor.xpath("./@data-src") or [""])[0].strip() - or (anchor.xpath(".//img/@src") or [""])[0].strip() - ) - parent = anchor.getparent() - remarks = "" - if parent is not None: - remarks = "".join( - parent.xpath(".//*[contains(@class,'note') or contains(@class,'text')]//text()") - ).strip() - - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": self._to_display_text(title), - "vod_pic": self._build_url(pic), - "vod_remarks": self._to_display_text(remarks), - } - ) - return items - - def _build_category_url(self, tid, pg, extend): - page = int(pg) - values = dict(self.filter_def.get(str(tid), {"by": "time"})) - if isinstance(extend, dict): - values.update(extend) - - by = str(values.get("by", "time")) - url = f"{self.host}/genre/{tid}.html" - if page > 1 or by != "time": - url += f"?page={page}&by={by}" - return url - - def _request_html(self, path_or_url, referer=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - headers = dict(self.headers) - headers["Referer"] = referer or self.headers["Referer"] - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def homeVideoContent(self): - html = self._request_html(self.host) - return {"list": self._extract_cards(html)[:24]} - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_category_url(str(tid), str(pg), extend if isinstance(extend, dict) else {}) - items = self._extract_cards(self._request_html(url)) - page = int(pg) - return { - "list": items, - "page": page, - "limit": 20, - "total": page * 30 + len(items), - } - - def _pick_info(self, html, label): - matched = re.search(rf"]*>{label}[：:](.*?)", str(html or ""), re.S) - return self._to_display_text(matched.group(1) if matched else "") - - def _parse_play_sources(self, html): - root = self.html(html) - if root is None: - return [] - - groups = [] - tabs = [] - for tab in root.xpath("//*[@id='playTab']//a[starts-with(@href,'#con_playlist_')]"): - tabs.append( - { - "id": (tab.xpath("./@href") or [""])[0].replace("#", ""), - "name": self._to_display_text("".join(tab.xpath(".//text()"))), - } - ) - - for tab in tabs: - episodes = [] - for anchor in root.xpath(f"//*[@id='{tab['id']}']//a[contains(@href,'/play/')]"): - href = (anchor.xpath("./@href") or [""])[0].strip() - matched = re.search(r"/play/(\d+-\d+-\d+)\.html", href) - if not matched: - continue - title = self._to_display_text("".join(anchor.xpath(".//text()"))) or "正片" - episodes.append(f"{title}${matched.group(1)}") - if episodes: - groups.append({"from": tab["name"], "urls": "#".join(episodes)}) - return groups - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - if root is None: - return {"list": []} - - title = "".join( - root.xpath("//h1[contains(@class,'text-overflow')][1]//text()") or root.xpath("//h1[1]//text()") - ).strip() - poster = ((root.xpath("//meta[@property='og:image']/@content") or [""])[0]).strip() - content = "".join( - root.xpath("//*[contains(@class,'details-content') or contains(@class,'detail-sketch')][1]//text()") - ).strip() - actors = [self._to_display_text(text) for text in root.xpath("//li[contains(.,'主演')]//a/text()")] - directors = [ - self._to_display_text(text) - for text in root.xpath("//li[contains(.,'導演') or contains(.,'导演')]//a/text()") - ] - play_groups = self._parse_play_sources(html) - - return { - "list": [ - { - "vod_id": str(vod_id), - "vod_name": self._to_display_text(title), - "vod_pic": self._build_url(poster), - "vod_content": self._to_display_text(content), - "vod_remarks": self._pick_info(html, "狀態") or self._pick_info(html, "状态"), - "type_name": self._pick_info(html, "類別") or self._pick_info(html, "类别"), - "vod_year": self._pick_info(html, "年代") or self._pick_info(html, "年份"), - "vod_area": self._pick_info(html, "國家/地區") or self._pick_info(html, "国家/地区"), - "vod_actor": ",".join([item for item in actors if item]), - "vod_director": ",".join([item for item in directors if item]), - "vod_play_from": "$$$".join([item["from"] for item in play_groups]), - "vod_play_url": "$$$".join([item["urls"] for item in play_groups]), - } - ] - } - - def detailContent(self, ids): - raw = ids[0] - url = raw if str(raw).startswith("http") else f"{self.host}/detail/{raw}.html" - html = self._request_html(url) - matched = re.search(r"/detail/(\d+)\.html", url) - vod_id = matched.group(1) if matched else str(raw) - return self._parse_detail_page(html, vod_id) - - def _normalize_search_keyword(self, text): - value = self._to_display_text(text).lower() - return re.sub(r"[\s\-_—–·•:：,，.。!?！？'\"“”‘’()（）\[\]【】{}]", "", value) - - def _build_search_tokens(self, keyword): - base = self._normalize_search_keyword(keyword) - if not base: - return [] - - tokens = [base] - simplified = re.sub( - r"线上看|線上看|全集|連續劇|连续剧|電視劇|电视剧|動漫|动漫|電影|电影|綜藝|综艺", - "", - base, - ).strip() - if simplified and simplified not in tokens: - tokens.append(simplified) - - stripped = re.sub(r"第\d+[集季部篇]?$", "", simplified) - stripped = re.sub(r"\d+$", "", stripped) - if stripped and stripped not in tokens: - tokens.append(stripped) - - return sorted([item for item in tokens if item], key=len, reverse=True) - - def _score_search_result(self, vod_name, keyword): - name = self._normalize_search_keyword(vod_name) - best = 0 - for token in self._build_search_tokens(keyword): - if name == token: - best = max(best, 1000 + len(token)) - elif name.startswith(token): - best = max(best, 800 + len(token)) - elif token in name: - best = max(best, 600 + len(token)) - elif len(name) >= 2 and name in token: - best = max(best, 450 + len(name)) - return best - - def _refine_search_results(self, items, keyword): - scored = [] - for item in items: - score = self._score_search_result(item.get("vod_name", ""), keyword) - if score > 0: - scored.append((score, item)) - - if scored: - scored.sort(key=lambda pair: (-pair[0], pair[1].get("vod_name", ""))) - return [item for _, item in scored] - - loose_key = self._normalize_search_keyword(keyword) - return [ - item - for item in items - if loose_key and loose_key in self._normalize_search_keyword(item.get("vod_name", "")) - ] - - def searchContent(self, key, quick, pg="1"): - url = f"{self.host}/find/-------------.html?wd={quote(str(key))}&page={pg}" - html = self._request_html(url) - raw_items = self._extract_cards(html) - items = self._refine_search_results(raw_items, key) - page = int(pg) - return { - "list": items, - "page": page, - "limit": len(items), - "total": len(items), - } - - def _extract_player_data(self, html): - matched = re.search(r"var\s+player_data\s*=\s*(\{[\s\S]*?\})\s*;?\s*", str(html or ""), re.S) - if not matched: - return {} - try: - return json.loads(matched.group(1)) - except Exception: - return {} - - def _decode_play_url(self, player_data): - raw = str(player_data.get("url", "")).strip() - encrypt = str(player_data.get("encrypt", "0")).strip() - if not raw: - return "" - if encrypt == "1": - return unquote(raw) - if encrypt == "2": - try: - decoded = base64.b64decode(raw).decode("utf-8") - return unquote(decoded) - except Exception: - return "" - return raw - - def _is_direct_media_url(self, url): - return bool(re.match(r"^https?://.*\.(m3u8|mp4|flv|m4s)(\?.*)?$", str(url or ""), re.I)) - - def _build_parse_context(self, raw_url, play_from, play_page_url): - base = "https://play.gimyai.tw/v/" - referer = f"https://play.gimyai.tw/v/?url={quote(raw_url)}" - if play_from in ["JD4K", "JD2K", "JDHG", "JDQM"]: - base = "https://play.gimyai.tw/d/" - referer = ( - f"https://play.gimyai.tw/d/?url={quote(raw_url)}" - f"&jctype={play_from}&next={quote(play_page_url)}" - ) - elif play_from == "NSYS": - base = "https://play.gimyai.tw/n/" - referer = ( - f"https://play.gimyai.tw/n/?url={quote(raw_url)}" - f"&jctype={play_from}&next={quote(play_page_url)}" - ) - return { - "parse_url": f"{base}parse.php?url={quote(raw_url)}&_t=1", - "referer": referer, - "origin": "https://play.gimyai.tw", - } - - def playerContent(self, flag, id, vipFlags): - play_id = str(id) - play_page_url = play_id if play_id.startswith("http") else f"{self.host}/play/{play_id}.html" - page_headers = { - "User-Agent": self.headers["User-Agent"], - "Referer": play_page_url, - "Origin": self.host, - } - - html = self._request_html(play_page_url, referer=play_page_url) - player_data = self._extract_player_data(html) - raw_url = self._decode_play_url(player_data) - - if self._is_direct_media_url(raw_url): - return { - "parse": 0, - "jx": 0, - "url": raw_url, - "header": {"User-Agent": self.headers["User-Agent"], "Referer": play_page_url}, - } - - if raw_url: - context = self._build_parse_context(raw_url, str(player_data.get("from", "")).strip(), play_page_url) - parse_text = self._request_html(context["parse_url"], referer=context["referer"]) - try: - parse_json = json.loads(parse_text or "{}") - except Exception: - parse_json = {} - - media_url = str( - parse_json.get("url") or parse_json.get("video") or parse_json.get("playurl") or "" - ).strip() - if media_url: - return { - "parse": 0, - "jx": 0, - "url": media_url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": context["referer"], - "Origin": context["origin"], - }, - } - - if raw_url.startswith("http"): - return { - "parse": 1, - "jx": 1, - "url": raw_url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": context["referer"], - }, - } - - return {"parse": 1, "jx": 1, "url": play_page_url, "header": page_headers} diff --git a/py/剧迷.txt b/py/剧迷.txt new file mode 100644 index 0000000..2a9b040 --- /dev/null +++ b/py/剧迷.txt @@ -0,0 +1,15 @@ +// ignore +//@name:剧迷 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:+PGhT/Fh3cRERsyR +//@ek:base64:bJMiZ1V9p16E+tEmA+uquK+mZ8A3za+buPJJBEwzUZYpUWP1jSNKdULl2fi1jfaU +//@hash:sha256:dba3fb1b987652af46079170cbb27452dba06d57d060f7a5584608f6dcbe2567 +//@sig:base64:8BM43dkniCe3DESH/kj+s3j84t6iNUJKT7fOVIsojw0L1zN3m8lt2X2F2svCSOnqnOl9aXEd+F+XPMZ1Noq+AQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/博看听书.py b/py/博看听书.py deleted file mode 100644 index 378ba35..0000000 --- a/py/博看听书.py +++ /dev/null @@ -1,288 +0,0 @@ -# coding=utf-8 -import json -import sys -from urllib.parse import urlencode - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "博看听书" - self.api_host = "https://api.bookan.com.cn" - self.search_host = "https://es.bookan.com.cn" - self.instance_id = "25304" - self.headers = { - "User-Agent": "Mozilla/5.0 (Linux; Android 10; Mobile) AppleWebKit/537.36", - "Accept": "application/json, text/plain, */*", - } - self.classes = [ - {"type_id": "1305", "type_name": "少年读物"}, - {"type_id": "1304", "type_name": "儿童文学"}, - {"type_id": "1320", "type_name": "国学经典"}, - {"type_id": "1306", "type_name": "文艺少年"}, - {"type_id": "1309", "type_name": "育儿心经"}, - {"type_id": "1310", "type_name": "心理哲学"}, - {"type_id": "1307", "type_name": "青春励志"}, - {"type_id": "1312", "type_name": "历史小说"}, - {"type_id": "1303", "type_name": "故事会"}, - {"type_id": "1317", "type_name": "音乐戏剧"}, - {"type_id": "1319", "type_name": "相声评书"}, - ] - self.force_order = [ - "相声评书", - "国学经典", - "故事会", - "历史小说", - "音乐戏剧", - "青春励志", - "少年读物", - "儿童文学", - "文艺少年", - "育儿心经", - "心理哲学", - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def _sort_classes(self): - order_map = {name: index for index, name in enumerate(self.force_order)} - return sorted(self.classes, key=lambda item: order_map.get(item["type_name"], 999)) - - def _to_int(self, value, default=0): - try: - return int(str(value)) - except Exception: - return default - - def _build_url(self, base_url, params=None): - query = { - str(key): value - for key, value in (params or {}).items() - if value is not None and value != "" - } - return f"{base_url}?{urlencode(query)}" if query else base_url - - def _api_get(self, path, params=None, host=None): - target_host = str(host or self.api_host).rstrip("/") - target = self._build_url(f"{target_host}/{str(path or '').lstrip('/')}", params or {}) - try: - response = self.fetch(target, headers=self.headers, timeout=10, verify=False) - except Exception: - return {} - if response.status_code != 200: - return {} - try: - return json.loads(response.text or "{}") - except Exception: - return {} - - def _search_get(self, path, params=None): - return self._api_get(path, params=params, host=self.search_host) - - def _fetch_category_books(self, category_id, page=1, limit=24): - payload = self._api_get( - "/voice/book/list", - { - "instance_id": self.instance_id, - "page": page, - "category_id": category_id, - "num": limit, - }, - ) - return ((payload.get("data") or {}).get("list") or []) - - def _fetch_album_info(self, album_id): - payload = self._api_get("/voice/album/get", {"album_id": album_id}) - data = payload.get("data") or {} - if not isinstance(data, dict) or not data: - return {"success": False, "data": None} - return { - "success": True, - "data": { - "vod_name": str(data.get("title") or data.get("name") or "未知标题"), - "vod_pic": str(data.get("cover") or ""), - "vod_author": str(data.get("author") or ""), - "vod_desc": str(data.get("description") or "暂无简介"), - "created_at": str(data.get("created_at") or ""), - "updated_at": str(data.get("updated_at") or ""), - }, - } - - def _fetch_album_units(self, album_id): - per_page = 200 - first = self._api_get( - "/voice/album/units", - {"album_id": album_id, "page": 1, "num": per_page, "order": 1}, - ) - first_data = first.get("data") or {} - items = list(first_data.get("list") or []) - total = self._to_int(first_data.get("total"), len(items)) - if total <= per_page: - return items - page_count = (total + per_page - 1) // per_page - for page in range(2, page_count + 1): - payload = self._api_get( - "/voice/album/units", - {"album_id": album_id, "page": page, "num": per_page, "order": 1}, - ) - items.extend(((payload.get("data") or {}).get("list") or [])) - return items - - def _find_album_from_categories(self, album_id): - for cls in self._sort_classes(): - for page in range(1, 6): - books = self._fetch_category_books(cls["type_id"], page, 24) - if not books: - break - hit = next((item for item in books if str((item or {}).get("id") or "") == str(album_id)), None) - if hit: - return { - "vod_name": str(hit.get("name") or hit.get("title") or ""), - "vod_pic": str(hit.get("cover") or ""), - "vod_author": str(hit.get("author") or ""), - "found": True, - } - if len(books) < 24: - break - return {"vod_name": "", "vod_pic": "", "vod_author": "", "found": False} - - def _format_book(self, item, fallback_remark=""): - row = item or {} - vod_id = str(row.get("id") or "") - if not vod_id: - return None - return { - "vod_id": vod_id, - "vod_name": str(row.get("name") or row.get("title") or ""), - "vod_pic": str(row.get("cover") or ""), - "vod_remarks": str(row.get("author") or fallback_remark or ""), - } - - def homeContent(self, filter): - classes = self._sort_classes() - videos = [] - for cls in classes: - for item in self._fetch_category_books(cls["type_id"], 1, 24): - row = self._format_book(item, cls["type_name"]) - if not row: - continue - row["vod_remarks"] = f"{str((item or {}).get('author') or '').strip()} {cls['type_name']}".strip() - videos.append(row) - return {"class": classes, "list": videos} - - def homeVideoContent(self): - return {"list": self.homeContent(False).get("list", [])} - - def categoryContent(self, tid, pg, filter, extend): - if not any(item["type_id"] == str(tid) for item in self.classes): - return {"page": 1, "limit": 24, "total": 0, "list": []} - page = self._to_int(pg, 1) - payload = self._api_get( - "/voice/book/list", - { - "instance_id": self.instance_id, - "page": page, - "category_id": tid, - "num": 24, - }, - ) - data = payload.get("data") or {} - items = [self._format_book(item) for item in (data.get("list") or [])] - return { - "page": page, - "limit": 24, - "total": self._to_int(data.get("total"), len(items)), - "list": [item for item in items if item], - } - - def detailContent(self, ids): - album_id = str((ids or [""])[0] or "").strip() - if not album_id: - return {"list": []} - category_info = self._find_album_from_categories(album_id) - album_info = self._fetch_album_info(album_id) - detail = album_info.get("data") if album_info.get("success") else {} - units = self._fetch_album_units(album_id) - if not units: - return {"list": []} - - episodes = [] - for index, chapter in enumerate(units, start=1): - play_id = str((chapter or {}).get("file") or "").strip() - if not play_id: - continue - title = str((chapter or {}).get("title") or f"第{index}集").strip() - episodes.append(f"{index}.{title}${play_id}") - if not episodes: - return {"list": []} - - detail = detail or {} - vod_name = str( - category_info.get("vod_name") - or detail.get("vod_name") - or ((units[0] or {}).get("album_title") or "") - or ((units[0] or {}).get("title") or "未知标题") - ) - vod_pic = str( - category_info.get("vod_pic") - or detail.get("vod_pic") - or ((units[0] or {}).get("cover") or "") - ) - vod_author = str(category_info.get("vod_author") or detail.get("vod_author") or "") - created_at = str(detail.get("created_at") or (units[0] or {}).get("created_at") or "") - updated_at = str(detail.get("updated_at") or (units[0] or {}).get("updated_at") or "") - vod_desc = str(detail.get("vod_desc") or (units[0] or {}).get("description") or "暂无简介") - - return { - "list": [ - { - "vod_id": album_id, - "vod_name": vod_name, - "vod_pic": vod_pic, - "vod_remarks": f"{vod_author + ' ' if vod_author else ''}共{len(episodes)}集", - "vod_content": vod_desc, - "vod_actor": f"▶️创建于 {created_at}" if created_at else "", - "vod_director": f"▶️更新于 {updated_at}" if updated_at else "", - "vod_year": f"{created_at.split('-')[0]}年" if created_at else "", - "vod_play_from": "博看听书", - "vod_play_url": "#".join(episodes), - } - ] - } - - def searchContent(self, key, quick, pg="1"): - keyword = str(key or "").strip() - if not keyword: - return {"page": 1, "limit": 0, "total": 0, "list": []} - page = self._to_int(pg, 1) - payload = self._search_get( - "/api/v3/voice/book", - { - "instanceId": self.instance_id, - "keyword": keyword, - "pageNum": page, - "limitNum": 20, - }, - ) - data = payload.get("data") or {} - items = [self._format_book(item) for item in (data.get("list") or [])] - return { - "page": page, - "limit": 20, - "total": self._to_int(data.get("total"), len(items)), - "list": [item for item in items if item], - } - - def playerContent(self, flag, id, vipFlags): - return { - "parse": 0, - "url": str(id or ""), - "header": {"User-Agent": self.headers["User-Agent"]}, - } diff --git a/py/博看听书.txt b/py/博看听书.txt new file mode 100644 index 0000000..576f301 --- /dev/null +++ b/py/博看听书.txt @@ -0,0 +1,15 @@ +// ignore +//@name:博看听书 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:iOsUcM4B8a9EhtsZ +//@ek:base64:tmDOKvMZkW5ZTSZ/C4RW3SjFRjKXbGF9EqPDR+eSsIAP2ylVTAip8Eem00gD6PH6 +//@hash:sha256:dab1e7e57928d22dd6bccbd25aa3dc34d175d3919bd9aca635386b0ed7aff650 +//@sig:base64:Iht+9dYS+Q5Txs4jSx4XxhFmCOhJsUB9CQZUHM3A/MNLbXMYdQHm/D4W2aTNFCZ7X9L9XNHOyEPiyaRWI1q4AQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/双星.py b/py/双星.py deleted file mode 100644 index eb167fb..0000000 --- a/py/双星.py +++ /dev/null @@ -1,186 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - BASE_URL = "https://1.star2.cn" - UA = ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0" - ) - CATEGORIES = [ - ("ju", "国剧"), - ("zy", "综艺"), - ("mv", "电影"), - ("rh", "日韩"), - ("ym", "英美"), - ("wj", "外剧"), - ("dm", "动漫"), - ] - PAN_TITLES = { - "quark": "夸克资源", - "ali": "阿里资源", - "115": "115资源", - "tianyi": "天翼资源", - "uc": "UC资源", - "baidu": "百度资源", - "xunlei": "迅雷资源", - "123pan": "123资源", - "yd": "移动云盘资源", - } - PAN_ORDER = ["quark", "ali", "115", "tianyi", "uc", "baidu", "xunlei", "123pan", "yd"] - - def __init__(self): - self.name = "双星" - self.cookie = "" - - def init(self, extend=""): - response = self.fetch( - self.BASE_URL, - headers={"User-Agent": self.UA, "Referer": self.BASE_URL}, - allow_redirects=False, - timeout=15, - ) - if response.status_code != 200: - return None - self.cookie = "; ".join([f"{name}={value}" for name, value in dict(response.cookies).items()]) - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": [{"type_id": type_id, "type_name": type_name} for type_id, type_name in self.CATEGORIES]} - - def homeVideoContent(self): - return {"list": []} - - def _headers(self): - headers = {"User-Agent": self.UA, "Referer": self.BASE_URL} - if self.cookie: - headers["cookie"] = self.cookie - return headers - - def _detect_pan_type(self, link): - text = str(link or "").strip().lower() - if "quark" in text: - return "quark" - if "115.com" in text: - return "115" - if "cloud.189.cn" in text: - return "tianyi" - if "drive.uc.cn" in text or "uc.cn" in text: - return "uc" - if "pan.baidu.com" in text: - return "baidu" - if "xunlei" in text: - return "xunlei" - if "123pan" in text: - return "123pan" - if "caiyun" in text or "139.com" in text: - return "yd" - if "aliyundrive" in text or "alipan" in text: - return "ali" - return "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _get_html(self, url): - response = self.fetch(url, headers=self._headers(), timeout=15) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - for node in root.xpath("/html/body/div/div/main/div/ul/li"): - href = "".join(node.xpath(".//div[contains(@class,'a')]//a[1]/@href")).strip() - title = self._clean_text("".join(node.xpath(".//div[contains(@class,'a')]//a[1]//text()"))) - if not href or not title: - continue - items.append({"vod_id": href, "vod_name": title, "vod_pic": "", "vod_remarks": ""}) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - items = self._parse_cards(self._get_html(f"{self.BASE_URL}/{str(tid).strip()}_{page}/")) - return {"page": page, "limit": 15, "total": (page - 1) * 15 + len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - items = self._parse_cards(self._get_html(f"{self.BASE_URL}/search/?keyword={quote(keyword)}&page={page}")) - return {"page": page, "total": len(items), "list": items} - - def _build_pan_lines(self, share_links): - groups = {} - seen = set() - for link in share_links: - raw = str(link or "").strip() - pan_type = self._detect_pan_type(raw) - if not raw or not pan_type or raw in seen: - continue - seen.add(raw) - groups.setdefault(pan_type, []).append(f"{self.PAN_TITLES[pan_type]}${raw}") - if not groups: - return {"vod_play_from": "", "vod_play_url": ""} - names = [name for name in self.PAN_ORDER if name in groups] - return { - "vod_play_from": "$$$".join(names), - "vod_play_url": "$$$".join("#".join(groups[name]) for name in names), - } - - def detailContent(self, ids): - vod_id = str((ids or [""])[0] or "").strip() - if not vod_id: - return {"list": []} - html = self._get_html(urljoin(self.BASE_URL, vod_id)) - root = self.html(html) - if root is None: - return {"list": []} - title = self._clean_text( - "".join( - root.xpath( - "/html/body/div/div[contains(@class,'s20erx') and contains(@class,'erx-content')]/main/article/h1//text()" - ) - ) - ) - share_links = [ - str(value).strip() - for value in root.xpath("//*[@id='maximg']//div[contains(@class,'dlipp-cont-bd')]//a[@href]/@href") - ] - play = self._build_pan_lines(share_links) - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": "", - "vod_remarks": "", - "vod_content": "", - "vod_director": "", - "vod_actor": "", - "vod_play_from": play["vod_play_from"], - "vod_play_url": play["vod_play_url"], - } - ] - } - - def playerContent(self, flag, id, vipFlags): - target = str(id or "").strip() - if self._detect_pan_type(target): - return {"parse": 0, "playUrl": "", "url": target} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/双星.txt b/py/双星.txt new file mode 100644 index 0000000..94027b4 --- /dev/null +++ b/py/双星.txt @@ -0,0 +1,15 @@ +// ignore +//@name:双星 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:uUGl+RasYrsSNyhm +//@ek:base64:3Yd3bQfAFe9+gBQKaNY1LLW+pK8fl50AXSVIgWIyUaWZA09UcLh+lUlgpiYuJIy9 +//@hash:sha256:f4aaf22f4758ba367ef4e29aef4d25e7e400e8260a13efd36c9ac7cad042079f +//@sig:base64:nF2cTYMobwGRDbo45aVXB+6Cl1NafCJSQp+sPs/EGQd0oJzOPtBilKRGZmFChn8Vm67qpRDLT+SyNE4V6jdXAw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/听书.txt b/py/听书.txt index 6a5d240..fd5bc4a 100644 --- a/py/听书.txt +++ b/py/听书.txt @@ -7,9 +7,9 @@ //@wrap:hkdf-aes-keywrap //@sign:ed25519 //@kid:k2026_04 -//@nonce:base64:WYs2uLHLSH8MZCnc -//@ek:base64:Jpc+F36Oo+gbAft1S/MYMvs1AtRWhupGVRn2p0jYNkoi0kChsLp4epV2xZMWOPal +//@nonce:base64:6405cph7uzLO6qJD +//@ek:base64:9aX2KcDIx9kHNvODsbG3WVJ1dp/uS40g9kl/Tyc+4joNSTLDvXMw1LCCL26vFqZj //@hash:sha256:7b4b05845d44d3d2dbd8fa505b75d3f0630396f7eb27982e2f3a4a2686648aa6 -//@sig:base64:4/Ilca6cumGYDJFlsWNi1YRH+MXKfuXPkQ5gJPlAwQjWdFO+OkaqxxF6sc6dYrpL0nLLUhYZ9ipN5+NJ+QQXBg== +//@sig:base64:WuFPyq11CPryXtKL6dFcvIfoQCeuXRw+TCg2RAb0K+R1aRScK2HEMtajhFBoshG7jSBFlhY68jeNW00aLhxYAg== // ignore -payload.base64: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 \ No newline at end of file +payload.base64:LQl823IUi2xc6pFSoEJ819lEhHjzh07TQIersY4dxh9Ozh4e+YjFBkfYqR2HJRBGiLRuQvb/c5YQC3yq+Y/G3mAHr4V+MhA4Org8MXpZR+RHQ47fqxZfD4uhJZFmixImdAStWahS8U8AUQeAL5QlD+Cv+DNM2+xW5m+ayVHcSk/H56tWyRnTZNdr7H+Fnr0sfyBp/6GIQyRVqnUeaIxfSpHB1ngB2EOVJihEdBYMPuGkXQn2krjotj142z3EiYAHXZg7oJ0a/VGCLz6i65bxMQc87ZVOPCEN2oVSFXMyYEfnSunkzgtOM1YNvnkD///AUvTNUOcwMSgzC8YCtKStXeSYfKaloRnv9yIiQYioOCtvfg1CvpMa1sp2ZaFVUyMqqqFyqytoLxlNVR4qHfQAeUxrZZNMzeH50J4b8CYMwgjZxmqE9rxWZU5mJr3AgYRPkFjaFNXN7A26VihbM8OzhyCGN97/iNBXHSIUI2ZDjyIEhlnNnnAyXGX16ZUPJGLE5yT6dDuTahwWkuW5Z4mbezgdm5oV8L4JsHMtTOazjLNCUdbHZJMHtf8seRFe/p2RoWyx8WU/zj+jkPOCojGsPpEizoh72OEq9rsHByEeeT6baYNHHwsKqGRGyl2MnlBisXyZRId8KlyKuS8wddAJCNv813ODY54d6rRk+gAAfL3ECptwMNEUHCjTN8ckZZU4HZnBeH3vLlnE20Ck0N4D3M/Dq/jrMMEvselta3lnIfH2KeW/edb6yiPpgSS5X8gAzb1sX5POjLyomndg1Jf/wi5Zrygzuf583EUJRDlcXppzJtGUhpS3jCI9Y6/fDz7B+eGDRPYHGDvTSOxzbgcPdTUJG/INv/CYKybERBn8rM5ioZZBD95z00uLwA5RvprNbYdELSxuOBCbDniSo+qNgE+BfsRwZQXRWsXoV73Ky4JXgls+gHOsQpSVtNiSDSgJu/zAoFhO5XPa1G2Zt4b2XQmpxTsyD0J2T5FgGKLcG/QgYXZzayN6rnP1VD4pAhi3yFimrAuo1IOZSa3Uw3/H6subYwQBsM3alNcoEaxcMyiRrgPOAugTfsu9AbDhD8rRtefTulck9nnqCxRm2KMZCtfxZlLoCSzeOdLVMWgeebddZQOTLPkGkIvd1pS3wIvy4CFcqYtbcb7iEHeqO1FQBjod63GuIc2Wmhz9P9TREZr3kGBd8FpYDbjniy51a0//YGtVmHlruDXdOVaWVJBPMBHYpMsXE2TfWuVdN+R+1Ci4Jl7Vd9SQbIUiHVY9AT5w72LwE91fmiv1RIJO7tVAGigAXIVl3jXH+eUzSSmcREpiS2KwnVUNY25QT65mv8LN+gNR1iMWpRNefVgekVL8r4+wb4jQkpQlI702UMmPV9o70QdTexNNuAQ2Pyyd8JTsUdDy/H3eon1zDsfEXEJIwVm7X+16xCLYxjr4RYELrlXvxGieKitHVwha3RPBGhdvgRfICyyJTYsFGABURBBkyJHvGWE93sKKQ4mOVCBjQtluKB01P+eW6TsO1te2lIPBpLJ/4OPWRjxy2K/eN3Q2WHuPFzlj8BXk2TP6wVT2aLP2grV45G1e22rh0Cwp5sKQKYdBsizYDTUmArG0ewSRSRJlwIEfGkyZgd8ShOyAKIIoD3Vz6lObRLcdERuemMi7+Jk6wrVNsN1yk5BSqs1ODwlBw6bjVu8zCnbuHdK+4/eJJ5wlnh8TYPUlmKgLcp4DhOHiwWwVszzehkbDa7Rs+InZepEtqKSeAehfdmts6VyUrIt0Yw/LofKwxTXeuuetwU3jHIbvVZzNgbOkbV7Hu749DHhbJz5x6SJ8/TwVys7ELu+JFf1MpwXJUhKwqpLMCX7fnQSieHdjV2dWI1f2wuQPVRR0EcPIGYwmCMKeAZ9LpnvJpjLVZyiYwkohWv6iNtvrKUiNBKasrVwf4vQn0vFjijzVi4DeuWmRnImctT5nkOVNGnpdShB0UZV0ZTnpmmjkhzLZ9YqcBj0pFYET6/0f7nFFvjPb3woqvABtecTH6Rz0FbOfnBOo3YPPRCMATez+euP4hInKtSDB9T8bofYMCEC98BtBAuleKDA7S3J18++MfWTmHIaVnr6fRSrsdQAZhR/6ZXYRPoogF7h/SJC1H7xY8YxKMjx3UoRLumgenHXeO6UPk/LocBtPjGqmLvVIBi0DdKQA+hVTh0igY6Thsz1ALnSsY7TUNtM3MTultEijEytPq7l+i0IGAjkROS7yzx2VwH62iYJLm1tyhwQ38aCgURqOykA5oQTtrB530WZ0S09Rsq3MNkN5gITItl0s7tNu0hcf04LUhWWn7Sglbr6V8eQZzJIuWXXseDG5a70bkBsR5oF/UgCoGkoLASVEqKLWNET9UD4XcxUDAn+U5AVkOlGjlnDg0ETlOOmmukbqBoUi2bH1LexeCVnFKd2cAFGlwE8/nC2uX9KgOL83u7UiZclj+osQYVZF27EC4QJMPo3LoF4aIM3SrSfvykVJ9wls7HGXYXsVxLENQWNaP23zuS9BD8g6a86n7rpxC8UZ0mdUS65EeC9sks+jKBujoWPAoHvgqrv8XOGc1qPVOq8R+U/ocBOcfssV3pMB5YzLlrw0aaOkrJeob/Gahijp0P3NXX0B1gDMpLzkrqXjQMpHnr8KILwlGZpgZsaTtUeiBVkgKBF0s4J+MH4XXD/5DgB1PZyJwfMFEeHdbfc/igxUEc/xD3jbjKDA6VPO8kwf2a7MUpNIeLP7J75DVvJucYCE2fwKw9nmO6+g2Rk9AY3vX8l23KgjX00CtUKigDnmpNGL0t9pwUqXGW2Ht6KKiX2dar3FoLPeQrYBX9dfDsDAP1qPGS4sBgmySAGBv9FCHPytXIVdwU0kxMvDzxPSwJRD4CEEN+zHIgrhkmR3x8W6V5Fedz5wE1lqp5BJQ59qYBW4C5YhmCkvrHl3FRPWU+NHTnfnkcX5hWxI+O/YXzCrOIrIoVdjvot+lI5UZtvIySWaEgjsNIyUgQupwxYGsa5cZKS9GrT0spIZdDUGM3mXDkHFdUu43OBGgHFYwXtDFMSa7pKfDCz3BztOt8Sbj5YDBKv+R4S/ub6eUGpm/b51RLlfSsOimx8kNRR2rqrS74Tx3T05g2hXFFsbKBM5ZfdDpLOV5XYa56quzJhMuvYm/ggsbcZaJlRNFxFb9fykDjL0FmYXmC7ufQwHZcCl9Ir+Q6FLf/eA5oZtmlndariD0bP8SO/SjYZkKvUpFH6M6ViejgpKnKmll/IZVfhUI6E+wZt4pV+34nh6LvNX70s9lXDnnG7GPpOmlMhoxHLfJaaNoMrJeU53FgqsDWZqhSeb200eA+U3+vGtwnbfd9LKHcUChvGcAR5WRmWPSJdwgGg5nTf1Wa1gnLjEnwpDA/R25azy/5TL8lX+N38mZyjeXDrCZ7CQqdT9qazCYcdy3VP+9/xPJsMpS2qXSptSVUYYXWBSEYUmMZ9BkyAMIDQciZo0GQmDVmBKr3Rnig7lI/M9SAM5PGmEEvB+5ozlSnjFSxVxXmUNozMUFGndJf7ggSVa3eTW2/jkJrJabgipUMNPuTFp98Jgjva2p9Z9bTe0KixEqtetqReEwU2lCN/mlrX3AJil1yG72DN5p9r3aHJAAP6gHhIpwjCJKeGmyb//THx3X3MIjtnst5JtZVuBXcQGNJk0W517uHWSmEa24/bqcaTv7luWMga79EvaENefilIDAgz2UgQhPEJPposVBfCMA3EWkEhBSNksR1Y0954FYw+BH4lZu3xYTcXupLWY46PBGqS9P5DW2mfAhWBb8wLHZ9oWZTSsKtn4Dr26T9ala3L63Hfid/Y+jNia/uVUmQYaoUquy6ETQ4P0LjDnwE4vK2ZFehHZ5ZLzLJ6fB8lG4OBqJiveEZ3YNmEANz2EkjEsHcAFCXbN7OVmPnTC2dDEAyw0xvZG5WOvUN91kdTDkS0A0eTKhx9/JctfmWcEzXFZVG/16YwtPnKO05iJdQhftPuEPmkP+OonZJyoyQvG0C1WUVpJaEDJNO+95/0sLAb9PetOIvaOxbq1Sf7+gGkofmiK5B+A7SPtQhLRo4RdTE5UWtrVcso1KPPxaW7yYZ/1ykM47JXD2JwoEjcW2nqwgir9UmS5kwZYBF4xiZ0o1jBTGCGlLwPD2nirDtOIKSWwFocHm1QUmKChSDL6Lh6wy7U5EatlGWS3an3mW7WB4TPJ4vPqx6UJDYAN2rYzFZLbFY/8MbVW+8tU2xWO6bvVHSiZR8nQpcb0JX2s7UVgy3uPGjFGFLwsRj8FjvaREs9beGuntAxlOjX6Laq+b2WKMvb/5sdcsGKa/RX7zvwqnHbj1Dee93IlZ2/FkO9XTHWUAiJhzGZRAZqSMnHDCOzPpJZRDYCjyssuyRG6Yak4sWk1qLEh+hUlwsdIkaOQ3gjF/3XULsGEVb8iyy6xfme3+y95R///uQ+50rzCJngT+uV2cgNJZdukPPslH677xx/dm5VIpKlMKt1jJ9KmPKGNB7d6SMhDYCawzlpjj9CmRNRK9DONVFQ1C3V3IzH4BWJ9ygBOBg0YiLhf0cOwQqD+7xi/gfmvQMVUdO0b2Xoz1RvzhnWfMgziprXYVk59aAKGOSVRd3S85UDS2EWoaj8WktIvOXPMXTT9WaeW4ZPOPP040S1MwIcONhRute/kZ182p9UOoXvWgtZ3hGK1pv2ebhtMUgabLm0alsvtw5gxuZcFMPX47ZVbdfbrq3k8V7/tiogzwDCY9S3M7233NcXaDgdO4QIPYBszRK2KUXT+GKr6zxRnL4/TPXbOg7xEzZMxIvyUMT01kpvp8HKMp9e1iRQ3DlRK6Nj2a49jMsYTo374mbEKbyyZu20QYzNGFnzCwqXZTz5tqYCJ2y1RLSmzbkp9TWzlYzjOMiOWJo6GMofs8Uv2X/jNWDlSRwuQ1slmA4YQxCpSB6ZcdqwF3RxEf2eIOTXnvqHD1bD5vf76rDdAApGKxtzPSUikfEVYX2jAHcvfLrsWTAV+fWRSDAohjvVkpYkooECrI84V3XJuHQTwiKrDv4SO4rS9K7xJRmU1oKjSC2MseuVh9cTtwjavW/eabmJ1iKgS6mqBMrk9CZjRTmxHRxaMYFcTHdOGzWPaf+clntQgUKE6M01UAurb6em1fxzj67yx+dFsJyomwOX5P8XTuqMyimM97FFdVNuP/sTGFM8THk9b0Z+abKGNXpZlVJvIEg7uiIOUpV0wxU8LUmEk/1vMCTOLCj2LnutEERqhdk8jYufC7naTUTEaR5SOmYMAsYeX4O1NYgkMXJMRFGofEX5XZCiSgv5TTSGxsOJtYF3t4z2V3f8+mTIaAFdz+6z8j1MZdoOOMurnhURbmRohXAVuEUSudMFfSv+XnXQE2uDpaxzrs9/+xZ7KBcGVs22Qhty/s8p0s0UasCHIlq/JmIdJo35yb8UUgVQvdVbYgUS3h5b79f0ZkbC2+XFTWKVKo1PDzSpxPWuZceCwHFqj91z3/NGgvX3+CXIRommrGF7MQnAw9O6c++X1oGE210VBJOZSXvI06+N9GOio83/rOqe8rBU1ASRuVwG4NwDpJi0LUH9CZ3N3A9ZhGp9vWe26WUE6SLaCkhXC60/SOWNuZ+1gVN/yrHMm5tRNeUeX//8l7Fq33L2jaadfAqmdHz/xtuS8iAUOLIa5MKYR6wco4MCgiQnJk4AjpvrKrKvPM+c81vmyUaysewi1AKyk++Sz6zXkKAXmt2T3sS4JvJxpUEwu6SgMAOZEevQpFDqFB6CHCMNBwGFvdaDXNsdDh8E32QYGPajzjsrHbXW6XJDhm+R+JqTKBDs+x2yhag5ezH5o6+9e4d9GCsWe65sU1Ai+4AkqaYd/pW9WEVm+Ss/3kihccFFa6wEJj1XfFKvSDnTiemIL4iWsXMVDO+vNPyfCZgL0iftClLHr5TonmtbSJAfVxjFdkiygYq14AsFNnxA3DeUqLR1UWsI+riSJzoIw94+5qzZKwI5S0Lr8c4XsmreyDcgI7EKq93AlrKmikfmrEzNUOlF1ECYez/6TWRTl3SbHFp/01mpl/e4uRlVKlU4YTWBr14KZ4YCGT5zx0yT+OT2+zDsq8YUN5WRAB3i8O9F68AV6K/XyWn7C/EQL7dhPVIgEa6xnaNJJuG8v3BSQN7GWonLv6fOUBC8m+hliBVpeCij7F+oFX+b/jhZsV9ep8LR6fHEc+ftAOOlR6+SOc0QqoqoNXyte0DQhiR60ydDKxll7p3npmPwyBpZeT9ET3MPqMw/5ShZB9hqQGMQecsk2xXRB+eXTqXJfWVuG8HY+JtxulDDOW1WxLfhhyGRw3q90H1qhokOIVT32XD8ctB578utC8Owic52yB1yK2BtDgi/Zvr5Jlic/3qqnXSsgBqQM5+hmfECZHzXWmB/RHi77yxb+CM/7I4d/YzDNwi/Isg3OiJpwfWjpxNC/rFMo89XuixDMv/JY7YX5uOx3N2617r+3hWqjH8YbFFmLSQ6CpAEieFYdd97tGJTBgLrD08hazQ1M9SqyY6Kl6eVzjR0/LuPyymvbLZ11xKHa1FZisHe+OAbkRo4gOGo8X6gajmbJu/Rhx7qb7aP6qwDFHHPml6Y9b2zvQQJZfFhcUP4Pzrw4bhppHcGNBmpoBHL8sBDCAQwcL/5kZLgZhoW6zpcTsHM4gXxwpN+f4JBjhPaI25lKmljgrKJlUrUEsdEFoZz7w0Cim+VmTQ8+n8MRV3L9c+n+xybGoCe/Wetz0+ZqO3BtFtWNhVzicR0TyYwHWVujLS7R18+q8p7njjf9eLIb5GEN7mm6/yWRatLZnpsCJ8RUclmX9F9DgGxoJRfHruH17GgeqlZzJWSCppGE/aZyH7F64uEKHY/shgVV+ErllxFXbn9Qy+2QXwBVS03XIy36E4u9+6IeuBantJOFDkTwFPT38/McJmGwgaNPdePLG3N3aRt5B0oAWHzfYWw4jRYSNCiNZ7AAfRAqkliIpY38yF8fajVQf1QN1JrfI5/LnYQsuq2oz3dKJ5QfKIPb4Wxlz69iJ8m5RG38tzfE6Piz81Z3qgTujwkTtKduzLwXwEJoYGR8jC4vPxWeyIn+lp/Cavuz0LFOwQzVEhFl2g9ka4yVu3NyUeVbVq5rFsENe3YvpKSVZOdFh3Wul7759VPp4K+HyPSlbkaFLc8awrHah6+0wfExKKBRqTEmjS/aZYObc4+RbuerycKcXYnz/wjHTLi8h2yQ/Co0J8uKrbiCrADW5a+jNNnwuI36ExsvYQAumtWHPpKMFfnUVfXeEz/3EbeDfE68wNBsoppmXGd5yLLF1TyIywSjjP7cYKFTW/a4yEP0/lZ7DzTJAj/CVb+T8glpjaA4gAhvzbiTpvrAdKh8qCAOkC3/Uu0nNgTjjGxdr0rhIAmbBtDLKAaDqrwn1wDdSD26BbWk2H06J+G5wk15IoRob0dfNJJ03wxMVolaAExiKhxdq2OtW7VM77aB4ADVdt/82z0lGwBkkuvYy2qyexwvV6Jn/OdsISJKZB0Cnn6xj/8rwazX2DXFb8ny0VTelnFbaddHWvjBPyTgu/8oo/gImpLf8lYrKjbEKQbAzecUJKOBxKvbTqB+glSNd6RJOTHvz4bAdVNNEpYC4TGucWk5jdwltX2cFYBVwUUpp0igCKWmzKFeVYbwqL7qLrLX81qu9i/PAlUUSJy7JPEn1odQaw+Ilo8K6nLLfLpzs9vWmdxHVMIRGhXEXWOmo7v9RHoKiaNSpHybV02OdoK2QH9FJ7TO2/ymgiRY0+yZPZJVXfUn+J9XSEayDbQKHZ473052Qnk8hl5Qd2Hqoe4pQK3dL61/ZMBeROXRgbexu8VlHmHK5sxzN5ZNrs3FYa6n2F43TNUuj43o1UXAJ31ZDsNKoHQ7/cWikmnme0PDy3kl3FhByBeNtB5PR0MajImRlmYnq8uD1nxYukypisFb49GeowLCLM3x97pzIvItv7lXYj48zq99h64875EciIjm6SV/q4Qe9tUBJpa2sBxRCQcH1KuN6nR5zdDkqUA7VBoR8WjIROW4NSEgrkZpse68Eu0hfx3Xl/Inmt4rQLH+OnXKg6cPfk7k3I/yBNUHRFIeHNLoj0FyrF1ZZoxGVAr/rqcp/Nw/CUHi9j73/7VdTHzwT9peS8EuQLJYai0D89+a/naWwl9Y9cg4JS2mnMYtTryYC1F0+a9MDZFxIAt0mVDPoHzjogS3sYj6IsSI/pRVvWSApSiGlNPwz1nsiooYXhvNRex5ZFbMyufi8YuEqyibcDSseIzXWhA4M6t9R3w2W8t9UxwMdNrF8+KRevfDKQmjZgjq214jnRZU6XY51QkT6RoTtP+mIqzoyMJAlpQjAK7caSA8xrY7IzZEhqNAoiV4sV4ahmQe7ZVzJEUMaCvWLw0a0lHIR3aAjpMzPt05ts50Od5+rSlxTOzmwHKw4/Ih/Pe8m5wsVGiYMt0QSpmLKn1lPdDK9B3CWnLxw69KabFKHNMtZ0YCJGHPTJVYXlwp0a+Iknoh2ioAfzJRC0AIWsYldvDg22Zi4bMBoiMSn9Z0QjpouEJ1ifwL6BFAGVK/Xi5NqqcPbsjYQfzdQBbcg1tz5JEdq98/0x1sF33Fu9Bswhcu5q2gJf5HOBnRKLRDhkFMcbTUVLHHKOKheyZwwQChTcueMkkGm6g+3N8MtYakCRSl/DCBG/2jzHJti3QlcXOVzotHXnUtZ5MtrMG6nlYUpo4TIHFXCbdZKHkXxjEfoEB8JIVMtmf77ZVcpsljQADLTaB5Snd2BYitdfQE5cue+509QlSLRicADDZKn3toaxOHjG4WXAUpBdEkTUefA0ItVNqiFXsmXeaGFGcrlRujSJZ+5KilvaMtQ+QDw//Z2pGq61P06O8RR9GDQoxPs+mbG55QITARwtUClqLnH8q7s4E5+cIsnCf822vAVnh8pU4LRlyz2HRhjUgV2Z1iFOtdpFRXTCJ/taEuIwG3V4HooLhgZxit5uymeWIA03hrpEkbmH+nVPIhWxnt4V+wV006RxuJ2wbkj7FPQDpw5Dorl5GahzoSP2giC2nR8x6s9zCx46g/4GcC+gMT3zNkyikmIvq23zM3NiUzC6Tu6tuezbaqxwlYi+B3SidWanaIPEUsrQSG0qRD/lAWQZb5oPsL3fPfu85PoiGCsV09u9kioKfBu8LWt1k+2nwuam8MQQ1Owm2gwyKnC37qDLt81MDhvHgti0kxYOmGtrPzhDNGaV0f1cNBVaPc4aZqwYVqvBvSKwnPO13+ek+rx5U3uXu39jMNtuB0DZvlF+gdCy9uGwWYjx6IAkFUn+h6coPeq42yyl2fQJvsBKeqUq5gQYmtVbaDK+JdbG78oFMRfm9N8xQd1rfsjFI/Un9cblUD1nuc1L+yDFd1cxnCea3O5hBS5xrPrczJBkQog3VQw0StyyQ5oerOrbEINzdYnk8F4asYeBc5Dp7rICnSdVM+TP58g8XzzlT+K2KlaUidPNGPlQnaES4dkxUOGWCiYnVRZCDdDf2Up9ENShwzXxN+e3v91Jbrmz1cWfdE9UyGecQDRbZi/apyxpOYYY0AzAadJKcN88VS+KVjkH7Adjd8nNwrxct98as7+ito2znLgZwzS2nvwpcl726TS+2cvLUfQoCmVxd475ydvy/smMi2Rs2fuOS3SeXDvm4e9AQd/fgbVBt3YLCAsPhjHK/rme2ffci5i5zkTsK6C1wg0gYrnohu7U77absgTIqwNU/Ue0ebUH0oqsaTMR85sbVFxldEDMRxxNLl//t4BH6le3ARyesP7uId/A8b5A4u5WxTcASk1A6BgGWNDMENI1OrxAS6Sy4NWic4tt0xO2o+Cp1iRc06nd33UK/SZ9ACAVglH5NI3nEbzumHNkKenODPOsI9fw9VuR0FW6mwWzlvGXrZ4IQeU6VOmtZK7QQERO/MVrOHJQ8euBKdgMnjebzX3q4whrJH8R1GG+8W7HczD5mK1Ah/GFDOwFfvdgomOj3T3YK6AtdES/TqJ2NYuFleCLPffvi5vbAeW0PiQVI/FDeUlN4vX6sjMopY1+GT42DbhrOaX6rVgqBr7oQMB+1e1QAQSdzp8ushEUXIpVzw8D7VT5yY1EwVEHJvdd6gNzuJDCLAewL/MqzmnHBPABONDTZlUMyGlL/CLLiDTe1VoeMSaO9hPP1IDtdReMmH/jwmQ84Vz118e8tsDnJPu7kMuEAoaDqRGi6y6PLSZKpZGufgU0SJ1gI4ojRMYwm1IeT5nhyPkTEaswHKMBdZgTrleUAUEQ/QOdDCCiENNN4VQ2qurpitN5WjX74tRAtTW8UPFdXwRhT11e3de9bCFcKWbAiltr5eAtg+/lIgGxOvQY2uQgbtP+v4aDjiRrbz+dmFnJg6UnC3aQFNBXVbAQ4RMuuyXFTCXe2QeS88qFRLP47jF56UV9dGk6p62fTS2g0OIQQabhCQpAoeZpnvalo918IwqGR8Esq1kEX8pLfZy6M0Z2w9I3ew3HmzgSpUNQeYWgiYM0pWADC1KjMKSRLwHpJsaKdmKBM0bo8PkB5OW1Hd9K5GD0ubmqV7fcnn6lCvacbQT6ey6NisnCrH/EwlCfSoOBBFrHiBqOyZC5Rarhu7/VmEoklxB4yKP5fWQ4OFkHn30eTngErE7vxymuwvkTIZS+3YEJLyukU72yGXYyV84RFHhhe6G2MhRp8g3SY+LlcLJCEvCNVAfwY1LcnumeW20D9fm5ig00g6s27WE73CEXLN/11Efb143zJ4TlalEYXVTEh2CF4eJ9O2ZXO4rttkMEtMfDBQmgB6/OuJjhQGaepweIgq4DaI/7Oggy+g5YbY3/y+2PDd0dJ9m4uvT1eqWuianGKxME6hlVbgcxDzp+/wt0ioL5cgSaUd+iL4S1T97p46inVYpfLbJq0kOygUB6rICVVuTFp2MgBE60INBrd2GdeJh7RZHpdTg8xsKj8k3evUsXLirPgsSqRU5kHoS6RCN5NKYy77YgBkSeGqLZzPVuRyjQBGDaaPxErWtglfRxKPbxV33X9rSgYisgdfF1x5qyFxWBDlP66ghhOwaIipBoWO3ku2BYczE93V5nx2tjccJTfSmoe2gNwrgkwQgbTmkNMpRQb8szdYLasQPPj/nea+1VKf8ZfSk8mIeoSqKgeFqhc4c/J7yFlmpPRsPDKoTqUZhCeiGfme3jgGNce1/zcUGL+z2LqK4B6Mt3TKOrp9z1QumGJUO77+GXb/Fp47yfvkz1sljY74j3bFPWuOx9O9rHEZ3Kkb3iM72P/19AKwX5ALyTD5fY66uiIaQms7rKl6ml1cIoo473Y8rZnDHwkeqoGLhIxNXsC38KiykNbS5MDMoI5km6Kis7wu \ No newline at end of file diff --git a/py/听友FM.py b/py/听友FM.py deleted file mode 100644 index b0486ff..0000000 --- a/py/听友FM.py +++ /dev/null @@ -1,584 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -import time -from hashlib import sha256 -from urllib.parse import quote - -from Crypto.Cipher import AES -from Crypto.Cipher import ChaCha20_Poly1305 -from Crypto.Random import get_random_bytes -from lxml import html as lxml_html - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "听友FM" - self.host = "https://tingyou.fm" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/146.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - "Origin": self.host, - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - } - self.payload_key_hex = "ea9d9d4f9a983fe6f6382f29c7b46b8d6dc47abc6da36662e6ddff8c78902f65" - self.payload_version = 1 - self.classes = [ - {"type_id": "46", "type_name": "有声小说"}, - {"type_id": "11", "type_name": "武侠小说"}, - {"type_id": "19", "type_name": "言情通俗"}, - {"type_id": "21", "type_name": "相声小品"}, - {"type_id": "14", "type_name": "恐怖惊悚"}, - {"type_id": "17", "type_name": "官场商战"}, - {"type_id": "15", "type_name": "历史军事"}, - {"type_id": "9", "type_name": "百家讲坛"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def _get_headers(self, extra=None): - headers = dict(self.headers) - if extra: - headers.update(extra) - return headers - - def _normalize_url(self, url): - value = str(url or "").strip() - if not value: - return "" - if value.startswith("http://") or value.startswith("https://"): - return value - if value.startswith("//"): - return "https:" + value - if value.startswith("/"): - return self.host + value - return value - - def _safe_text(self, node): - if node is None: - return "" - if isinstance(node, str): - return re.sub(r"\s+", " ", node).strip() - return re.sub(r"\s+", " ", "".join(node.itertext())).strip() - - def _load_html(self, content): - text = str(content or "").strip() or "" - return lxml_html.fromstring(text) - - def _get_html(self, path): - url = path if str(path).startswith("http") else self.host + (path if str(path).startswith("/") else "/" + str(path)) - try: - response = self.fetch(url, headers=self._get_headers(), timeout=10, verify=False) - except Exception: - return "" - return response.text if getattr(response, "status_code", 0) == 200 else "" - - def _hex_to_bytes(self, hex_text): - return bytes.fromhex(str(hex_text or "").strip()) - - def _bytes_to_hex(self, data): - return bytes(data or b"").hex() - - def _encrypt_payload(self, plain_text): - key = self._hex_to_bytes(self.payload_key_hex) - iv = get_random_bytes(12) - cipher = AES.new(key, AES.MODE_GCM, nonce=iv) - encrypted, tag = cipher.encrypt_and_digest(str(plain_text or "").encode("utf-8")) - return self._bytes_to_hex(bytes([self.payload_version]) + iv + encrypted + tag) - - def _decrypt_xchacha_body(self, key, nonce, body): - cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce) - return cipher.decrypt_and_verify(body[:-16], body[-16:]) - - def _decrypt_aes_gcm_payload(self, raw, attempts): - key = self._hex_to_bytes(self.payload_key_hex) - last_error = None - for iv_start, cipher_start in attempts: - try: - iv = raw[iv_start:iv_start + 12] - body = raw[cipher_start:] - encrypted = body[:-16] - tag = body[-16:] - cipher = AES.new(key, AES.MODE_GCM, nonce=iv) - return cipher.decrypt_and_verify(encrypted, tag).decode("utf-8") - except Exception as exc: - last_error = exc - if last_error: - raise last_error - raise ValueError("aes decrypt failed") - - def _decrypt_payload(self, hex_text): - raw = self._hex_to_bytes(hex_text) - if len(raw) < 2: - raise ValueError("payload too short") - version = raw[0] - key = self._hex_to_bytes(self.payload_key_hex) - if version == 1: - if len(raw) >= 41: - try: - plain = self._decrypt_xchacha_body(key, raw[1:25], raw[25:]) - return plain.decode("utf-8") - except Exception: - pass - return self._decrypt_aes_gcm_payload(raw, [(1, 13), (0, 12), (2, 14)]) - if version == 2: - nonce = raw[1:25] - body = raw[25:][::-1] - plain = self._decrypt_xchacha_body(key, nonce, body) - return bytes(plain).decode("utf-8") - raise ValueError("unsupported payload version") - - def _make_dfp_cookie(self): - today_hex = format(int(time.strftime("%Y%m%d")), "x") - seed = f"{time.time()}|tingyou|{get_random_bytes(8).hex()}".encode("utf-8") - return f"dfp=f-{today_hex}:f-{sha256(seed).hexdigest()}" - - def _decode_nuxt_value(self, table, node, seen=None): - seen = seen or {} - markers = { - "ShallowReactive", - "Reactive", - "Ref", - "EmptyRef", - "Set", - "Map", - "Date", - "RegExp", - "BigInt", - "null", - "undefined", - "NaN", - "-0", - "Infinity", - "-Infinity", - } - if isinstance(node, int) and 0 <= node < len(table): - if node in seen: - return seen[node] - raw = table[node] - if isinstance(raw, list) and raw and isinstance(raw[0], str) and raw[0] in markers: - marker = raw[0] - if marker in ("ShallowReactive", "Reactive", "Ref"): - value = self._decode_nuxt_value(table, raw[1] if len(raw) > 1 else None, seen) - seen[node] = value - return value - if marker in ("EmptyRef", "null", "undefined", "NaN"): - seen[node] = None - return None - if isinstance(raw, dict): - seen[node] = {} - for key, value in raw.items(): - seen[node][key] = self._decode_nuxt_value(table, value, seen) - return seen[node] - if isinstance(raw, list): - seen[node] = [] - for item in raw: - seen[node].append(self._decode_nuxt_value(table, item, seen)) - return seen[node] - return raw - if isinstance(node, list): - return [self._decode_nuxt_value(table, item, seen) for item in node] - if isinstance(node, dict): - return {key: self._decode_nuxt_value(table, value, seen) for key, value in node.items()} - return node - - def _load_nuxt_root(self, html): - match = re.search(r']*id=["\']__NUXT_DATA__["\'][^>]*>([\s\S]*?)', str(html or ""), re.I) - if not match: - return {} - try: - payload = json.loads(match.group(1)) - except Exception: - return {} - if isinstance(payload, list) and len(payload) > 1: - return self._decode_nuxt_value(payload, 1) - return payload if isinstance(payload, dict) else {} - - def _pick_image(self, node): - if node is None: - return "" - for name in ("src", "data-src", "data-lazy-src", "data-original", "data-url"): - value = node.get(name, "") - if value and not value.startswith("data:image"): - return self._normalize_url(value) - return "" - - def _parse_album_anchor(self, anchor, fallback_type_id="", fallback_type_name=""): - href = anchor.get("href", "") - match = re.search(r"/albums/(\d+)", href) - if not match: - return None - album_id = match.group(1) - images = anchor.xpath(".//img") - image = images[0] if images else None - title = "" - if image is not None: - title = image.get("alt", "").strip() - if not title: - first_p = anchor.xpath(".//p") - title = self._safe_text(first_p[0]) if first_p else self._safe_text(anchor) - text = self._safe_text(anchor) - periods = re.search(r"(\d+)\s*期", text) - status = re.search(r"(连载中|已完结)", text) - person = re.search(r"播音[：:]\s*([^\s·|]+)", text) or re.search(r"作者[：:]\s*([^\s·|]+)", text) - remarks = " · ".join( - [value for value in [periods.group(1) + "期" if periods else "", status.group(1) if status else "", person.group(1) if person else ""] if value] - ) - return { - "vod_id": album_id, - "vod_name": title or ("专辑" + album_id), - "vod_pic": self._pick_image(image), - "vod_remarks": remarks, - "type_id": str(fallback_type_id or ""), - "type_name": fallback_type_name or "", - } - - def _unique_by_id(self, items): - seen = set() - result = [] - for item in items or []: - vod_id = str((item or {}).get("vod_id", "")).strip() - if not vod_id or vod_id in seen: - continue - seen.add(vod_id) - result.append(item) - return result - - def _category_name(self, tid): - for item in self.classes: - if item["type_id"] == str(tid): - return item["type_name"] - return "" - - def _parse_home_list(self, html, fallback_type_id="", fallback_type_name=""): - document = self._load_html(html) - items = [] - for anchor in document.xpath("//a[contains(@href, '/albums/')]"): - if not anchor.xpath(".//img"): - continue - item = self._parse_album_anchor(anchor, fallback_type_id, fallback_type_name) - if item: - items.append(item) - return self._unique_by_id(items) - - def _parse_home_nuxt(self, html): - root = self._load_nuxt_root(html) - tabs = ((root.get("data") or {}).get("index-home-tabs") or {}) - items = [] - for bucket in tabs.values(): - tab_items = bucket.get("items") if isinstance(bucket, dict) else None - if not isinstance(tab_items, list): - continue - for item in tab_items: - album_id = str((item or {}).get("id") or "").strip() - if not album_id: - continue - status = "连载中" if str(item.get("status")) == "1" else "已完结" if str(item.get("status")) == "0" else "" - remarks = " · ".join( - [ - value - for value in [ - f"{item.get('chapterTotal')}期" if item.get("chapterTotal") else "", - status, - str(item.get("teller") or item.get("author") or "").strip(), - ] - if value - ] - ) - items.append( - { - "vod_id": album_id, - "vod_name": str(item.get("title") or ("专辑" + album_id)), - "vod_pic": self._normalize_url(item.get("cover") or item.get("cover_url") or ""), - "vod_remarks": remarks, - "type_id": "", - "type_name": str(item.get("categoryName") or "").strip(), - } - ) - return self._unique_by_id(items) - - def _map_nuxt_album_item(self, item, tid, type_name): - data = item or {} - album_id = str(data.get("id") or "") - if not album_id: - return None - status = "连载中" if str(data.get("status")) == "1" else "已完结" if str(data.get("status")) == "0" else "" - remarks = " · ".join( - [ - value - for value in [ - f"{data.get('count')}期" if data.get("count") else "", - status, - str(data.get("teller") or data.get("author") or "").strip(), - ] - if value - ] - ) - return { - "vod_id": album_id, - "vod_name": str(data.get("title") or ("专辑" + album_id)), - "vod_pic": self._normalize_url(data.get("cover_url") or ""), - "vod_remarks": remarks, - "type_id": str(tid or ""), - "type_name": type_name or "", - } - - def _parse_category_nuxt(self, html, tid): - root = self._load_nuxt_root(html) - data = (root.get("data") or {}).get(f"categoryAlbums-{tid}") or {} - items = [self._map_nuxt_album_item(item, tid, self._category_name(tid)) for item in data.get("data", [])] - return { - "page": int(data.get("page") or 1), - "pages": int(data.get("pages") or 1), - "list": [item for item in items if item], - } if items else None - - def _parse_search_nuxt(self, html): - root = self._load_nuxt_root(html) - data = root.get("data") or {} - search_value = None - for key, value in data.items(): - if "search" in str(key).lower(): - search_value = value - break - results = [] - - def walk(node): - if isinstance(node, list): - for item in node: - walk(item) - return - if not isinstance(node, dict): - return - if node.get("id") and (node.get("title") or node.get("name")): - pic = node.get("cover") or node.get("cover_url") or node.get("pic") or node.get("pic_url") - if pic: - results.append( - { - "vod_id": str(node.get("id")), - "vod_name": str(node.get("title") or node.get("name") or ""), - "vod_pic": self._normalize_url(pic), - "vod_remarks": str(node.get("desc") or node.get("subtitle") or node.get("author") or node.get("teller") or "").strip(), - } - ) - for value in node.values(): - walk(value) - - walk(search_value) - return self._unique_by_id(results) - - def _parse_detail_page(self, html, album_id): - document = self._load_html(html) - name = self._safe_text(next(iter(document.xpath("//section[contains(@class, 'album-pannel')]//*[contains(@class, 'album-intro')]//h1")), None)) - if not name: - name = document.xpath("string(//meta[@property='og:title']/@content)").strip() - pic = "" - images = document.xpath("//section[contains(@class, 'album-pannel')]//img") - if images: - pic = self._pick_image(images[0]) - if not pic: - pic = self._normalize_url(document.xpath("string(//meta[@property='og:image']/@content)").strip()) - content = ( - document.xpath("string(//meta[@name='description']/@content)").strip() - or document.xpath("string(//meta[@property='og:description']/@content)").strip() - or self._safe_text(next(iter(document.xpath("//*[contains(@class, 'album-desc') or contains(@class, 'desc') or contains(@class, 'intro')]")), None)) - ) - type_name = "" - for node in document.xpath("//section[contains(@class, 'album-pannel')]//*[contains(@class, 'pods')]//span"): - text = self._safe_text(node) - if text.startswith("分类:"): - type_name = text.split(":", 1)[1].strip() - break - root = self._load_nuxt_root(html) - nuxt_data = root.get("data") or {} - album_detail = nuxt_data.get(f"album-detail-{album_id}") or {} - album_chapters = nuxt_data.get(f"album-chapters-{album_id}") or {} - if not name: - name = str(album_detail.get("title") or "").strip() - if not pic: - pic = self._normalize_url(album_detail.get("cover_url") or "") - if not content: - content = str(album_detail.get("synopsis") or "").strip() - play_items = [] - chapters = album_chapters.get("chapters") or [] - if isinstance(chapters, list) and chapters: - for index, item in enumerate(chapters, start=1): - raw_index = item.get("index") - chapter_idx = int(raw_index) if isinstance(raw_index, (int, str)) and str(raw_index).isdigit() else index - title = str(item.get("title") or f"第{chapter_idx}集").strip() - play_items.append(f"{title}${album_id}|{chapter_idx}") - else: - for index, item in enumerate(document.xpath("//ul[contains(@class, 'chapter-list')]/li[contains(@class, 'chapter-item')]"), start=1): - num_text = self._safe_text(next(iter(item.xpath("./p")), None)) - title = self._safe_text(next(iter(item.xpath(".//*[contains(@class, 'title')]")), None)) or f"第{index}集" - chapter_idx = int(num_text) if str(num_text).isdigit() else index - play_items.append(f"{title}${album_id}|{chapter_idx}") - return { - "vod_id": str(album_id), - "vod_name": name or ("专辑" + str(album_id)), - "vod_pic": pic, - "vod_content": content, - "type_name": type_name, - "vod_play_from": "听友FM", - "vod_play_url": "#".join(play_items), - } - - def _normalize_api_result(self, data): - value = data - if isinstance(value, dict) and isinstance(value.get("payload"), str): - plain = self._decrypt_payload(value["payload"]) - try: - return json.loads(plain) - except Exception: - return plain - if isinstance(value, str) and re.fullmatch(r"[0-9a-fA-F]+", value or ""): - plain = self._decrypt_payload(value) - try: - return json.loads(plain) - except Exception: - return plain - return value - - def _api_post(self, path, body=None, extra_headers=None): - url = path if str(path).startswith("http") else self.host + (path if str(path).startswith("/") else "/" + str(path)) - payload = None - if body is not None: - payload = self._encrypt_payload(json.dumps(body, ensure_ascii=False, separators=(",", ":"))) - headers = self._get_headers({"X-Payload-Version": str(self.payload_version)}) - if payload is not None: - headers["Content-Type"] = "text/plain" - if extra_headers: - headers.update(extra_headers) - response = self.post(url, data=payload, headers=headers, timeout=10, verify=False) - if getattr(response, "status_code", 0) >= 400: - raise ValueError("api request failed") - text = getattr(response, "text", "") or "" - try: - data = json.loads(text) - except Exception: - data = text - return self._normalize_api_result(data) - - def _extract_play_url(self, value): - candidates = [] - - def walk(node): - if isinstance(node, str): - if node.startswith("http://") or node.startswith("https://"): - candidates.append(node) - return - if isinstance(node, list): - for item in node: - walk(item) - return - if not isinstance(node, dict): - return - for key, item in node.items(): - if isinstance(item, str) and (key.lower() in ("url", "src", "play", "audio", "file", "link") or item.startswith("http")): - candidates.append(item) - walk(item) - - walk(value) - for candidate in candidates: - if candidate.startswith("http://") or candidate.startswith("https://"): - return candidate - return "" - - def _anonymous_auth(self): - cookie = self._make_dfp_cookie() - data = self._api_post("/api/me", None, extra_headers={"Accept": "application/json", "Cookie": cookie}) - auth_token = str((data or {}).get("auth_token") or "").strip() - return { - "auth_token": auth_token, - "cookie": cookie, - "data": data or {}, - } - - def homeContent(self, filter): - html = self._get_html("/") - document = self._load_html(html) - classes = [] - seen = set() - for anchor in document.xpath("//a[contains(@href, '/categories/')]"): - href = anchor.get("href", "") - match = re.search(r"/categories/(\d+)", href) - if not match: - continue - type_id = match.group(1) - if type_id in seen: - continue - seen.add(type_id) - classes.append({"type_id": type_id, "type_name": self._safe_text(anchor) or self._category_name(type_id)}) - items = self._parse_home_nuxt(html) or self._parse_home_list(html) - return {"class": classes or list(self.classes), "list": items[:20]} - - def homeVideoContent(self): - return {"list": self.homeContent(False).get("list", [])} - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg or 1) - html = self._get_html(f"/categories/{tid}?sort=comprehensive&page={page}") - nuxt = self._parse_category_nuxt(html, tid) - items = (nuxt or {}).get("list") or self._parse_home_list(html, tid, self._category_name(tid)) - return {"page": (nuxt or {}).get("page", page), "limit": len(items), "total": len(items), "list": items} - - def detailContent(self, ids): - result = {"list": []} - for album_id in ids or []: - html = self._get_html(f"/albums/{album_id}") - vod = self._parse_detail_page(html, str(album_id)) - if vod: - result["list"].append(vod) - return result - - def searchContent(self, key, quick, pg="1"): - keyword = str(key or "").strip() - if not keyword: - return {"page": 1, "limit": 0, "total": 0, "list": []} - html = self._get_html(f"/search?q={quote(keyword)}") - items = self._parse_search_nuxt(html) - if not items: - items = self._parse_home_list(html) - lowered = keyword.lower() - filtered = [ - item for item in self._unique_by_id(items) - if lowered in f"{item.get('vod_name', '')} {item.get('vod_remarks', '')}".lower() - ] - return {"page": int(pg or 1), "limit": len(filtered), "total": len(filtered), "list": filtered} - - def playerContent(self, flag, id, vipFlags): - album_id, chapter_idx = str(id or "").split("|", 1) - fallback = f"{self.host}/audios/{album_id}/{chapter_idx}" - try: - auth = self._anonymous_auth() - extra_headers = { - "Accept": "application/json", - "Cookie": auth.get("cookie", ""), - } - if auth.get("auth_token"): - extra_headers["Authorization"] = f"Bearer {auth['auth_token']}" - payload = self._api_post( - "/api/play_token", - {"album_id": int(album_id), "chapter_idx": int(chapter_idx)}, - extra_headers=extra_headers, - ) - data = self._normalize_api_result(payload) - url = self._extract_play_url(data) - if url: - return {"parse": 0, "url": url, "header": self._get_headers(extra_headers)} - except Exception: - pass - return {"parse": 1, "url": fallback, "header": self._get_headers()} diff --git a/py/听友FM.txt b/py/听友FM.txt new file mode 100644 index 0000000..0528cbc --- /dev/null +++ b/py/听友FM.txt @@ -0,0 +1,15 @@ +// ignore +//@name:听友FM +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:GnBGDPFJvAlieIVy +//@ek:base64:CkwWU18GYXRq5bJ1EkxGMRxZiuE/7nRSs3sOrDgcGm2mnMk7UIm82dNg5b7sGXiI +//@hash:sha256:68de3b8e8a15d666f52cbc42f11ea361f6ebec8f35b7a7bf1c0fd76c385a3db7 +//@sig:base64:gOpo72Qrj7UoEYoK0CBy5wYkqoZaGxnv6utU4dHjr8DE2RMBRcWqtMAzyDWaixpj3sN4jNSPk0eeEBBlHLZoCA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/四万影视.py b/py/四万影视.py deleted file mode 100644 index 06f7483..0000000 --- a/py/四万影视.py +++ /dev/null @@ -1,298 +0,0 @@ -# coding=utf-8 -import json -import sys - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "四万影视" - self.host = "https://40000.me" - self.api = self.host + "/api/maccms" - self.fallback_pic = self.host + "/public/favicon.png" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0" - ), - "Referer": self.host + "/", - "Accept": "*/*", - } - self.classes = [ - {"type_id": "20", "type_name": "电影"}, - {"type_id": "30", "type_name": "电视剧"}, - {"type_id": "39", "type_name": "动漫"}, - {"type_id": "45", "type_name": "综艺"}, - {"type_id": "32", "type_name": "欧美"}, - ] - self.filter_type_options = { - "20": [ - {"n": "全部", "v": "20"}, - {"n": "动作片", "v": "21"}, - {"n": "喜剧片", "v": "22"}, - {"n": "恐怖片", "v": "23"}, - {"n": "科幻片", "v": "24"}, - {"n": "爱情片", "v": "25"}, - {"n": "剧情片", "v": "26"}, - {"n": "战争片", "v": "27"}, - {"n": "纪录片", "v": "28"}, - {"n": "理论片", "v": "29"}, - {"n": "预告片", "v": "52"}, - {"n": "电影解说", "v": "51"}, - ], - "30": [ - {"n": "全部", "v": "30"}, - {"n": "国产剧", "v": "31"}, - {"n": "欧美剧", "v": "32"}, - {"n": "香港剧", "v": "33"}, - {"n": "韩国剧", "v": "34"}, - {"n": "台湾剧", "v": "35"}, - {"n": "日本剧", "v": "36"}, - {"n": "海外剧", "v": "37"}, - {"n": "泰国剧", "v": "38"}, - {"n": "短剧大全", "v": "58"}, - ], - "39": [ - {"n": "全部", "v": "39"}, - {"n": "国产动漫", "v": "40"}, - {"n": "日韩动漫", "v": "41"}, - {"n": "欧美动漫", "v": "42"}, - {"n": "港台动漫", "v": "43"}, - {"n": "海外动漫", "v": "44"}, - {"n": "动画片", "v": "50"}, - ], - "45": [ - {"n": "全部", "v": "45"}, - {"n": "大陆综艺", "v": "46"}, - {"n": "港台综艺", "v": "47"}, - {"n": "日韩综艺", "v": "48"}, - {"n": "欧美综艺", "v": "49"}, - ], - "32": [ - {"n": "全部", "v": "32"}, - {"n": "欧美剧", "v": "32"}, - {"n": "欧美动漫", "v": "42"}, - {"n": "欧美综艺", "v": "49"}, - {"n": "海外剧", "v": "37"}, - ], - } - self.type_name_map = {item["type_id"]: item["type_name"] for item in self.classes} - self.subtype_parent_map = { - "20": "20", - "21": "20", - "22": "20", - "23": "20", - "24": "20", - "25": "20", - "26": "20", - "27": "20", - "28": "20", - "29": "20", - "51": "20", - "52": "20", - "30": "30", - "31": "30", - "32": "32", - "33": "30", - "34": "30", - "35": "30", - "36": "30", - "37": "32", - "38": "30", - "58": "30", - "39": "39", - "40": "39", - "41": "39", - "42": "32", - "43": "39", - "44": "39", - "50": "39", - "45": "45", - "46": "45", - "47": "45", - "48": "45", - "49": "32", - } - self.filters = self._build_filters() - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def _build_filters(self): - years = [{"n": "全部", "v": ""}] - for year in range(2026, 1999, -1): - years.append({"n": str(year), "v": str(year)}) - sort_values = [ - {"n": "时间", "v": "time"}, - {"n": "人气", "v": "hits"}, - {"n": "评分", "v": "score"}, - {"n": "点赞", "v": "up"}, - ] - filters = {} - for item in self.classes: - type_id = item["type_id"] - filters[type_id] = [ - {"key": "subType", "name": "分类", "init": type_id, "value": self.filter_type_options[type_id]}, - {"key": "year", "name": "年代", "init": "", "value": years}, - {"key": "sort", "name": "排序", "init": "time", "value": list(sort_values)}, - ] - return filters - - def homeContent(self, filter): - return {"class": self.classes, "filters": self.filters} - - def homeVideoContent(self): - return {"list": []} - - def _type_name_by_id(self, type_id): - raw = str(type_id or "") - parent = self.subtype_parent_map.get(raw, raw) - return self.type_name_map.get(parent, "") - - def _normalize_actor(self, value): - return str(value or "").replace("&#039;", "'").replace(" , ", ", ") - - def _normalize_vod(self, item): - return { - "vod_id": str(item.get("vod_id", "")), - "vod_name": str(item.get("vod_name", "")), - "vod_pic": str(item.get("vod_pic") or self.fallback_pic), - "vod_remarks": str(item.get("vod_remarks", "")), - "vod_year": str(item.get("vod_year", "")), - "type_name": str(item.get("type_name") or self._type_name_by_id(item.get("type_id"))), - "vod_actor": self._normalize_actor(item.get("vod_actor", "")), - } - - def _page_result(self, items, page, total=0): - return { - "page": int(page), - "limit": len(items), - "total": int(total) if total else len(items), - "list": items, - } - - def _parse_play_groups(self, item): - from_list = str(item.get("vod_play_from", "")).split("$$$") - url_list = str(item.get("vod_play_url", "")).split("$$$") - final_from = [] - final_url = [] - for index, raw_urls in enumerate(url_list): - raw_urls = str(raw_urls or "").strip() - if not raw_urls: - continue - line_name = str(from_list[index] if index < len(from_list) else "").strip() or f"线路{index + 1}" - episodes = [] - for episode_index, part in enumerate(raw_urls.split("#")): - chunks = str(part or "").split("$", 1) - if len(chunks) > 1: - title = chunks[0].strip() - play_id = chunks[1].strip() - else: - title = "" - play_id = chunks[0].strip() if chunks else "" - title = title or f"第{episode_index + 1}集" - if play_id: - episodes.append(f"{title}${play_id}") - if episodes: - final_from.append(line_name) - final_url.append("#".join(episodes)) - return {"vod_play_from": "$$$".join(final_from), "vod_play_url": "$$$".join(final_url)} - - def _api_get(self, params): - response = self.fetch( - self.api, - params=params, - headers=dict(self.headers), - timeout=10, - ) - if response.status_code != 200: - raise ValueError("api request failed") - data = json.loads(response.text or "{}") - if not isinstance(data, dict): - raise ValueError("api response is not object") - return data - - def categoryContent(self, tid, pg, filter, extend): - page = max(int(pg), 1) - values = dict(extend or {}) - params = { - "ac": "detail", - "t": str(values.get("subType") or tid), - "pg": page, - "by": str(values.get("sort") or "time"), - } - year = str(values.get("year") or "").strip() - if year: - params["h"] = year - try: - data = self._api_get(params) - except ValueError: - return {"page": page, "limit": 0, "total": 0, "list": []} - items = [self._normalize_vod(item) for item in data.get("list", [])] - return self._page_result(items, data.get("page", page), data.get("total", 0)) - - def searchContent(self, key, quick, pg="1"): - page = max(int(pg), 1) - keyword = str(key or "").strip() - if not keyword: - return {"page": page, "limit": 0, "total": 0, "list": []} - try: - data = self._api_get({"ac": "detail", "wd": keyword, "pg": page}) - except ValueError: - return {"page": page, "limit": 0, "total": 0, "list": []} - items = [self._normalize_vod(item) for item in data.get("list", [])] - return self._page_result(items, data.get("page", page), data.get("total", 0)) - - def detailContent(self, ids): - vod_id = str(ids[0] if isinstance(ids, list) and ids else ids or "").strip() - if not vod_id: - return {"list": []} - try: - data = self._api_get({"ac": "detail", "ids": vod_id}) - except ValueError: - return {"list": []} - item = (data.get("list") or [None])[0] - if not item: - return {"list": []} - normalized = self._normalize_vod(item) - play_data = self._parse_play_groups(item) - return { - "list": [ - { - "vod_id": normalized["vod_id"], - "vod_name": normalized["vod_name"], - "vod_pic": normalized["vod_pic"], - "type_name": normalized["type_name"], - "vod_year": str(item.get("vod_year", "")), - "vod_area": str(item.get("vod_area", "")), - "vod_director": str(item.get("vod_director", "")), - "vod_actor": normalized["vod_actor"], - "vod_content": str(item.get("vod_blurb") or item.get("vod_content") or ""), - "vod_remarks": str(item.get("vod_remarks", "")), - "vod_play_from": play_data["vod_play_from"], - "vod_play_url": play_data["vod_play_url"], - } - ] - } - - def playerContent(self, flag, id, vipFlags): - play_id = str(id or "").strip() - header = { - "User-Agent": self.headers["User-Agent"], - "Referer": self.host + "/", - } - if not play_id: - return {"parse": 1, "jx": 1, "url": "", "header": header} - if play_id.startswith("http://") or play_id.startswith("https://"): - return {"parse": 0, "jx": 0, "url": play_id, "header": header} - return {"parse": 1, "jx": 1, "url": play_id, "header": header} diff --git a/py/四万影视.txt b/py/四万影视.txt new file mode 100644 index 0000000..c7b2d85 --- /dev/null +++ b/py/四万影视.txt @@ -0,0 +1,15 @@ +// ignore +//@name:四万影视 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:zWuskxIGUsfX4emp +//@ek:base64:EPro5CKdXPM0ACfIKglJ7otTsiuwICZ5y4XC7IhCwWOGyOvxUuai7zZ2g6dJqRVo +//@hash:sha256:2381f050d53a81ebf80d67148978fbce803da5d039ddd6d7ad634aa69682a687 +//@sig:base64:znSfocVfaUhlz2SlE+mCH3mPg2VsUZEPnO8QgVH7qj3KUBF6gkiVoeKrjgLSXQhzO+cQeR9OXXUpN8FSC8OzBQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/在线之家.py b/py/在线之家.py deleted file mode 100644 index a9d9389..0000000 --- a/py/在线之家.py +++ /dev/null @@ -1,539 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -from urllib.parse import quote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "在线之家" - self.host = "https://www.zxzjhd.com" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/145.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "美剧"}, - {"type_id": "3", "type_name": "韩剧"}, - {"type_id": "4", "type_name": "日剧"}, - {"type_id": "5", "type_name": "泰剧"}, - {"type_id": "6", "type_name": "动漫"}, - ] - sort_values = [ - {"n": "时间", "v": "time"}, - {"n": "人气", "v": "hits"}, - {"n": "评分", "v": "score"}, - ] - common_years = [ - {"n": "全部", "v": ""}, - {"n": "2026", "v": "2026"}, - {"n": "2025", "v": "2025"}, - {"n": "2024", "v": "2024"}, - {"n": "2023", "v": "2023"}, - {"n": "2022", "v": "2022"}, - {"n": "2021", "v": "2021"}, - {"n": "2020", "v": "2020"}, - {"n": "2019", "v": "2019"}, - {"n": "2018", "v": "2018"}, - {"n": "2017", "v": "2017"}, - {"n": "2016", "v": "2016"}, - {"n": "2015", "v": "2015"}, - {"n": "2014", "v": "2014"}, - {"n": "2013", "v": "2013"}, - {"n": "2012", "v": "2012"}, - {"n": "2011", "v": "2011"}, - ] - drama_classes = [ - {"n": "全部", "v": ""}, - {"n": "剧情", "v": "剧情"}, - {"n": "喜剧", "v": "喜剧"}, - {"n": "爱情", "v": "爱情"}, - {"n": "动作", "v": "动作"}, - {"n": "悬疑", "v": "悬疑"}, - {"n": "恐怖", "v": "恐怖"}, - {"n": "奇幻", "v": "奇幻"}, - {"n": "惊悚", "v": "惊悚"}, - {"n": "犯罪", "v": "犯罪"}, - {"n": "科幻", "v": "科幻"}, - {"n": "音乐", "v": "音乐"}, - {"n": "其他", "v": "其他"}, - ] - self.filter_def = {key: {"cateId": key} for key in ["1", "2", "3", "4", "5", "6"]} - self.filters = { - "1": [ - { - "key": "class", - "name": "剧情", - "init": "", - "value": [ - {"n": "全部", "v": ""}, - {"n": "喜剧", "v": "喜剧"}, - {"n": "爱情", "v": "爱情"}, - {"n": "恐怖", "v": "恐怖"}, - {"n": "动作", "v": "动作"}, - {"n": "科幻", "v": "科幻"}, - {"n": "剧情", "v": "剧情"}, - {"n": "战争", "v": "战争"}, - {"n": "警匪", "v": "警匪"}, - {"n": "犯罪", "v": "犯罪"}, - {"n": "动画", "v": "动画"}, - {"n": "奇幻", "v": "奇幻"}, - {"n": "冒险", "v": "冒险"}, - ], - }, - { - "key": "area", - "name": "地区", - "init": "", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "香港", "v": "香港"}, - {"n": "台湾", "v": "台湾"}, - {"n": "欧美", "v": "欧美"}, - {"n": "韩国", "v": "韩国"}, - {"n": "日本", "v": "日本"}, - {"n": "泰国", "v": "泰国"}, - {"n": "印度", "v": "印度"}, - {"n": "俄罗斯", "v": "俄罗斯"}, - {"n": "其他", "v": "其他"}, - ], - }, - {"key": "year", "name": "年份", "init": "", "value": list(common_years)}, - {"key": "by", "name": "排序", "init": "time", "value": list(sort_values)}, - ], - "2": [ - {"key": "class", "name": "剧情", "init": "", "value": list(drama_classes)}, - {"key": "year", "name": "年份", "init": "", "value": list(common_years)}, - {"key": "by", "name": "排序", "init": "time", "value": list(sort_values)}, - ], - "3": [ - {"key": "class", "name": "剧情", "init": "", "value": list(drama_classes)}, - {"key": "year", "name": "年份", "init": "", "value": list(common_years)}, - {"key": "by", "name": "排序", "init": "time", "value": list(sort_values)}, - ], - "4": [ - {"key": "class", "name": "剧情", "init": "", "value": list(drama_classes)}, - {"key": "year", "name": "年份", "init": "", "value": list(common_years)}, - {"key": "by", "name": "排序", "init": "time", "value": list(sort_values)}, - ], - "5": [ - {"key": "year", "name": "年份", "init": "", "value": list(common_years)}, - {"key": "by", "name": "排序", "init": "time", "value": list(sort_values)}, - ], - "6": [ - { - "key": "class", - "name": "剧情", - "init": "", - "value": [ - {"n": "全部", "v": ""}, - {"n": "情感", "v": "情感"}, - {"n": "科幻", "v": "科幻"}, - {"n": "热血", "v": "热血"}, - {"n": "推理", "v": "推理"}, - {"n": "搞笑", "v": "搞笑"}, - {"n": "冒险", "v": "冒险"}, - {"n": "萝莉", "v": "萝莉"}, - {"n": "校园", "v": "校园"}, - {"n": "动作", "v": "动作"}, - {"n": "机战", "v": "机战"}, - {"n": "运动", "v": "运动"}, - {"n": "战争", "v": "战争"}, - {"n": "少年", "v": "少年"}, - ], - }, - { - "key": "area", - "name": "地区", - "init": "", - "value": [ - {"n": "全部", "v": ""}, - {"n": "国产", "v": "国产"}, - {"n": "日本", "v": "日本"}, - {"n": "欧美", "v": "欧美"}, - {"n": "其他", "v": "其他"}, - ], - }, - {"key": "year", "name": "年份", "init": "", "value": list(common_years)}, - {"key": "by", "name": "排序", "init": "time", "value": list(sort_values)}, - ], - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes, "filters": self.filters} - - def homeVideoContent(self): - return {"list": []} - - def _normalize_ext(self, extend): - if isinstance(extend, dict): - return extend - if not extend: - return {} - try: - return json.loads(str(extend)) - except Exception: - return {} - - def _build_url(self, value): - raw = str(value or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - if raw.startswith("/"): - return self.host + raw - return self.host + "/" + raw - - def _build_category_url(self, tid, pg, extend): - values = dict(self.filter_def.get(str(tid), {"cateId": str(tid)})) - values.update(self._normalize_ext(extend)) - path = ( - f"{values.get('cateId', tid)}-" - f"{values.get('area', '')}-" - f"{values.get('by', '')}-" - f"{values.get('class', '')}" - f"-----{int(pg)}---" - f"{values.get('year', '')}" - ) - return self._build_url(f"/vodshow/{path}.html") - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _fix_json_wrapped_html(self, html): - value = str(html or "").strip() - if value.startswith("<"): - return value - if value.startswith('"') and value.endswith('"'): - try: - parsed = json.loads(value) - if isinstance(parsed, str) and parsed.startswith("<"): - return parsed.strip() - except Exception: - return value - return value - - def _request_html(self, path_or_url, referer=None, extra_headers=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - headers = dict(self.headers) - headers["Referer"] = referer or self.headers["Referer"] - if isinstance(extra_headers, dict): - headers.update(extra_headers) - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return "" - return self._fix_json_wrapped_html(response.text or "") - - def _build_player_v2_headers(self): - return { - "Origin": self.host, - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", - "Accept-Language": "zh-CN,zh;q=0.9", - "Sec-Fetch-Dest": "iframe", - "Sec-Fetch-Mode": "navigate", - "Sec-Fetch-Site": "cross-site", - "Sec-Fetch-User": "?1", - "Upgrade-Insecure-Requests": "1", - } - - def _extract_vod_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"/?(voddetail/\d+\.html)", raw) - return matched.group(1) if matched else "" - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for node in root.xpath("//ul[contains(@class,'stui-vodlist')]//li"): - href = ((node.xpath(".//a[@href][1]/@href") or [""])[0]).strip() - vod_id = self._extract_vod_id(href) - title = ((node.xpath(".//a[@title][1]/@title") or [""])[0]).strip() - pic = ( - ((node.xpath(".//a[@data-original][1]/@data-original") or [""])[0]).strip() - or ((node.xpath(".//img[@data-original][1]/@data-original") or [""])[0]).strip() - or ((node.xpath(".//img[@src][1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(node.xpath(".//*[contains(@class,'pic-text')][1]//text()"))) - if not vod_id or not title or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - items = self._parse_cards(self._request_html(self._build_category_url(tid, pg, extend))) - return {"list": items, "page": page, "limit": 24, "total": page * 30 + len(items)} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - url = self._build_url("/vodsearch/{0}-------------.html".format(quote(str(key or "").strip()))) - items = self._parse_cards(self._request_html(url)) - return {"list": items, "page": page, "limit": len(items), "total": len(items)} - - def _extract_actor_like_field(self, html, label): - matched = re.search(rf"{label}：([\s\S]*?)

", str(html or "")) - if not matched: - return "" - texts = re.findall(r">([^<>]+)<", matched.group(1)) - clean = [self._clean_text(text) for text in texts if self._clean_text(text)] - return ",".join(clean) - - def _parse_detail_meta(self, html): - root = self.html(html) - if root is None: - return {} - title_line = self._clean_text( - "".join(root.xpath("//*[contains(@class,'stui-content__detail')]//*[contains(@class,'title')][1]//text()")) - ) - title_match = re.match(r"^(.*?)(?:\s+(19\d{2}|20\d{2}))?(?:\s+([^\s]+))?(?:\s+([^\s]+))?$", title_line) - vod_name = self._clean_text(title_match.group(1) if title_match else title_line) - vod_year = self._clean_text(title_match.group(2) if title_match else "") - vod_area = self._clean_text(title_match.group(3) if title_match else "") - vod_class = self._clean_text(title_match.group(4) if title_match else "") - return { - "vod_name": vod_name, - "vod_year": vod_year, - "vod_area": vod_area, - "vod_class": vod_class, - "vod_pic": self._build_url( - ((root.xpath("//*[contains(@class,'stui-content__thumb')]//img/@data-original") or [""])[0]).strip() - ), - "vod_content": self._clean_text( - "".join( - root.xpath( - "//*[contains(concat(' ', normalize-space(@class), ' '), ' detail ')][1]//text()" - ) - ) - ), - "vod_director": self._extract_actor_like_field(html, "导演"), - "vod_actor": self._extract_actor_like_field(html, "主演"), - } - - def _extract_playlists(self, html): - root = self.html(html) - if root is None: - return {"normal": [], "pan": []} - tabs = [self._clean_text("".join(node.xpath(".//text()"))) for node in root.xpath("//*[contains(@class,'stui-vodlist__head')]//h3")] - playlists = root.xpath("//*[contains(@class,'stui-content__playlist')]") - normal = [] - pan = [] - for index, playlist in enumerate(playlists): - tab_name = tabs[index] if index < len(tabs) else "" - items = [] - for anchor in playlist.xpath(".//a[@href]"): - href = ((anchor.xpath("./@href") or [""])[0]).strip() - name = self._clean_text("".join(anchor.xpath(".//text()"))) or "正片" - play_id = re.sub(r"^/+", "", href) - if not play_id: - continue - items.append( - { - "name": name, - "url": self._build_url(play_id), - "play_id": play_id, - "tab_name": tab_name, - } - ) - if any(keyword in tab_name for keyword in ["网盘", "百度", "夸克", "UC", "阿里", "迅雷"]): - pan.extend(items) - elif items: - normal.extend([f"{item['name']}${item['play_id']}" for item in items]) - return {"normal": normal, "pan": pan} - - def _extract_pan_url_from_play_page(self, html): - matched = re.search(r"player_[a-z0-9_]+\s*=\s*(\{[\s\S]*?\})\s*;?", str(html or ""), re.I) - if not matched: - return "" - try: - payload = json.loads(matched.group(1)) - except Exception: - return "" - return str(payload.get("url") or "").strip() - - def _detect_pan_type(self, tab_name, share_url): - text = str(share_url or "") - if "pan.baidu.com" in text: - return "baidu" - if "pan.quark.cn" in text: - return "quark" - if "drive.uc.cn" in text: - return "uc" - if "alipan.com" in text or "aliyundrive.com" in text: - return "aliyun" - if "pan.xunlei.com" in text: - return "xunlei" - name = str(tab_name or "").lower() - if "百度" in str(tab_name or ""): - return "baidu" - if "夸克" in str(tab_name or ""): - return "quark" - if "uc" in name: - return "uc" - if "阿里" in str(tab_name or "") or "aliyun" in name: - return "aliyun" - if "迅雷" in str(tab_name or ""): - return "xunlei" - return "" - - def _extract_pan_groups(self, items): - grouped = {} - seen = set() - order = ["quark", "baidu", "uc", "aliyun", "xunlei"] - for item in items: - play_html = self._request_html(item["url"], referer=self.headers["Referer"]) - share_url = self._extract_pan_url_from_play_page(play_html) - pan_type = self._detect_pan_type(item.get("tab_name", ""), share_url) - if not share_url or not pan_type: - continue - key = (pan_type, share_url) - if key in seen: - continue - seen.add(key) - grouped.setdefault(pan_type, []).append(f"{item['name']}${share_url}") - return [{"from": key, "urls": "#".join(grouped[key])} for key in order if grouped.get(key)] - - def detailContent(self, ids): - raw_id = str(ids[0]).strip() - url = raw_id if raw_id.startswith("http") else self._build_url("/" + raw_id.lstrip("/")) - html = self._request_html(url) - meta = self._parse_detail_meta(html) - playlists = self._extract_playlists(html) - pan_groups = self._extract_pan_groups(playlists["pan"]) - play_from = [] - play_url = [] - if playlists["normal"]: - play_from.append("zxzj") - play_url.append("#".join(playlists["normal"])) - for group in pan_groups: - play_from.append(group["from"]) - play_url.append(group["urls"]) - vod = { - "vod_id": raw_id, - "vod_name": meta.get("vod_name", ""), - "vod_pic": meta.get("vod_pic", ""), - "vod_content": meta.get("vod_content", ""), - "vod_remarks": "", - "vod_year": meta.get("vod_year", ""), - "vod_area": meta.get("vod_area", ""), - "vod_class": meta.get("vod_class", ""), - "vod_lang": "", - "vod_director": meta.get("vod_director", ""), - "vod_actor": meta.get("vod_actor", ""), - "vod_play_from": "$$$".join(play_from), - "vod_play_url": "$$$".join(play_url), - } - return {"list": [vod]} - - def _decrypt_url(self, encrypted_data): - raw = str(encrypted_data or "").strip() - if not raw or len(raw) % 2 != 0: - return "" - try: - reversed_hex = raw[::-1] - decoded = [] - for index in range(0, len(reversed_hex), 2): - decoded.append(chr(int(reversed_hex[index : index + 2], 16))) - text = "".join(decoded) - split_len = max((len(text) - 7) // 2, 0) - candidate = text[:split_len] + text[split_len + 7 :] - return candidate if candidate.startswith("http") else "" - except Exception: - return "" - - def _extract_iframe_url(self, html): - matched = re.search(r'"url"\s*:\s*"(https:[^"]*?)"', str(html or "")) - if matched: - value = matched.group(1).replace("\\/", "/") - if any(token in value for token in ["jx.zxzj", "player-v2", "/player", "/embed"]): - return value - matched = re.search(r"player_[a-z0-9_]+\s*=\s*(\{[\s\S]*?\})\s*;?", str(html or ""), re.I) - if not matched: - return "" - try: - payload = json.loads(matched.group(1)) - except Exception: - return "" - value = str(payload.get("url") or "").replace("\\/", "/") - return value if any(token in value for token in ["jx.zxzj", "player-v2", "/player", "/embed"]) else "" - - def _extract_result_v2_data(self, html): - matched = re.search(r"result_v2\s*=\s*(\{[\s\S]*?\})\s*;", str(html or "")) - if not matched: - return "" - try: - payload = json.loads(matched.group(1)) - except Exception: - return "" - return str(payload.get("data") or payload.get("url") or "").strip() - - def playerContent(self, flag, id, vipFlags): - raw_flag = str(flag or "").lower() - raw_id = str(id or "").strip() - if raw_flag in ("baidu", "quark", "uc", "aliyun", "xunlei"): - return {"parse": 0, "jx": 0, "playUrl": "", "url": raw_id, "header": {}} - - play_url = raw_id if raw_id.startswith("http") else self._build_url("/" + raw_id.lstrip("/")) - play_html = self._request_html(play_url, referer=self.headers["Referer"]) - iframe_url = self._extract_iframe_url(play_html) - if not iframe_url: - return {"parse": 1, "jx": 1, "playUrl": "", "url": play_url, "header": self.headers} - - iframe_headers = self._build_player_v2_headers() if "player-v2" in iframe_url else None - iframe_html = self._request_html(iframe_url, referer=play_url, extra_headers=iframe_headers) - encrypted = self._extract_result_v2_data(iframe_html) - final_url = self._decrypt_url(encrypted) - if not final_url: - fallback_url = iframe_url if "player-v2" in iframe_url else play_url - fallback_header = ( - {"Referer": play_url, "User-Agent": self.headers["User-Agent"]} - if fallback_url == iframe_url - else self.headers - ) - return { - "parse": 1, - "jx": 1, - "playUrl": "", - "url": fallback_url, - "header": fallback_header, - } - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": final_url, - "header": {"Referer": iframe_url, "User-Agent": self.headers["User-Agent"]}, - } diff --git a/py/在线之家.txt b/py/在线之家.txt new file mode 100644 index 0000000..649b95c --- /dev/null +++ b/py/在线之家.txt @@ -0,0 +1,15 @@ +// ignore +//@name:在线之家 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:v7bcuw8UrzYWJ6aP +//@ek:base64:MVfj4yvrmh2oKv1htLiEXTfchZdJdNqiGgv7d8bLWN+vq0XVHDh/SpkRRe+UFxQx +//@hash:sha256:9659eb27a4c9af57dd36aea5b79155cb402409bd33e40036888b690bfa89c632 +//@sig:base64:jDmbjh+l0knSjrkKQfxpGgdCP26sHTavnxZQN/StLpsvqVJ6Am0slyGqMAkQZ1VPomWAurEyXtflqo6zuPKQCw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/奕搜.py b/py/奕搜.py deleted file mode 100644 index 3b12b06..0000000 --- a/py/奕搜.py +++ /dev/null @@ -1,240 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "奕搜" - self.host = "https://ysso.cc" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/145.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "dy", "type_name": "电影"}, - {"type_id": "dsj", "type_name": "电视剧"}, - {"type_id": "zy", "type_name": "综艺"}, - {"type_id": "dm", "type_name": "动漫"}, - {"type_id": "jlp", "type_name": "纪录片"}, - {"type_id": "dj", "type_name": "短剧"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _extract_remark_from_title(self, title_text): - parts = re.findall(r"\[(.*?)\]", str(title_text or "")) - for part in parts: - text = part.strip() - if text.startswith("更"): - match = re.search(r"更\s*([0-9]+)", text) - return f"更新至{match.group(1)}集" if match else text - for part in parts: - text = part.strip() - if text.endswith("分"): - return f"评分:{text[:-1].strip()}" - for part in parts: - text = part.strip() - if re.match(r"^\d{4}$", text): - return f"首播:{text}" - return "" - - def _clean_title_text(self, title): - return re.sub(r"\s*\[.*?\]", "", str(title or "")).strip() - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10, verify=False) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_list_boxes(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for node in root.xpath("//*[contains(@class,'list-boxes')]"): - title_href = "".join(node.xpath(".//a[contains(@class,'text_title_p')][1]/@href")).strip() - fallback_href = "".join(node.xpath(".//*[contains(@class,'left_ly')]//a[1]/@href")).strip() - vod_id = title_href or fallback_href - title = self._clean_text("".join(node.xpath(".//a[contains(@class,'text_title_p')][1]//text()"))) - if not vod_id or not title or vod_id in seen: - continue - seen.add(vod_id) - pic = self._build_url("".join(node.xpath(".//img[contains(@class,'image_left')][1]/@src")).strip()) - remark = self._extract_remark_from_title(title) or self._clean_text( - "".join(node.xpath(".//*[contains(@class,'list-actions')]//span[1]//text()")) - ) - items.append( - { - "vod_id": vod_id, - "vod_name": self._clean_title_text(title), - "vod_pic": pic, - "vod_remarks": remark, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - items = self._parse_list_boxes(self._request_html(self._build_url(f"/{tid}.html?page={page}"))) - return {"page": page, "limit": len(items) or 20, "total": page * 30 + (len(items) or 20), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - url = self._build_url(f"/search.html?keyword={quote(keyword)}&page={page}") - items = self._parse_list_boxes(self._request_html(url)) - return {"page": page, "limit": len(items) or 20, "total": len(items), "list": items} - - def _identify_disk(self, value): - text = str(value or "").strip().lower() - if "pan.baidu.com" in text: - return "baidu" - if "pan.quark.cn" in text: - return "quark" - if "drive.uc.cn" in text: - return "uc" - if "alipan.com" in text or "aliyundrive.com" in text: - return "aliyun" - if "pan.xunlei.com" in text: - return "xunlei" - return "" - - def _disk_priority(self, name): - order = {"baidu": 1, "quark": 2, "uc": 3, "aliyun": 4, "xunlei": 5} - return order.get(name, 999) - - def _extract_share_links(self, root): - links = [] - seen = set() - for href in root.xpath("//a[@target='_blank']/@href"): - url = str(href or "").strip() - if not url.startswith(("http://", "https://")) or url in seen: - continue - seen.add(url) - links.append(url) - return links - - def _build_play_data(self, share_links): - unique_links = [] - seen = set() - for link in share_links: - if link and link not in seen: - seen.add(link) - unique_links.append(link) - grouped = {} - for link in unique_links: - disk = self._identify_disk(link) - if not disk: - continue - grouped.setdefault(disk, []).append(f"{disk}${link}") - if grouped: - names = sorted(grouped, key=self._disk_priority) - return { - "vod_play_from": "$$$".join(names), - "vod_play_url": "$$$".join("#".join(grouped[name]) for name in names), - } - if unique_links: - return { - "vod_play_from": "奕搜", - "vod_play_url": "#".join( - f"{index + 1}$push://{link}" for index, link in enumerate(unique_links) - ), - } - return {"vod_play_from": "奕搜", "vod_play_url": ""} - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - if not vod_id: - continue - html = self._request_html(self._build_url(vod_id)) - root = self.html(html) - if root is None: - continue - title = self._clean_text("".join(root.xpath("//h1[contains(@class,'articl_title')][1]//text()"))) - director_items = [] - actor_items = [] - for span in root.xpath("//*[@id='info']/span"): - key = self._clean_text( - "".join(span.xpath(".//*[contains(@class,'pl')][1]//text()")) - ).replace("：", "").replace(":", "") - names = [self._clean_text(text) for text in span.xpath(".//*[contains(@class,'attrs')]//a/text()")] - names = [name for name in names if name] - if "导演" in key or "编剧" in key: - for name in names: - if name not in director_items: - director_items.append(name) - if "主演" in key or "演员" in key: - for name in names: - if name not in actor_items: - actor_items.append(name) - content = "" - for text in root.xpath("//p/text()"): - cleaned = self._clean_text(text) - if len(cleaned) > 20: - content = cleaned - break - remarks = self._extract_remark_from_title(title) - body_text = self._clean_text("".join(root.xpath("//body//text()"))) - code_match = re.search(r"提取码[：:]\s*([a-zA-Z0-9]{4})", body_text) - if code_match: - remarks = f"{remarks} 提取码: {code_match.group(1)}".strip() - play = self._build_play_data(self._extract_share_links(root)) - result["list"].append( - { - "vod_id": vod_id, - "vod_name": self._clean_title_text(title), - "vod_pic": self._build_url( - "".join( - root.xpath( - "(//*[contains(@class,'tc-box') and contains(@class,'article-box')]//img)[1]/@src" - ) - ).strip() - ), - "vod_remarks": remarks, - "vod_director": ", ".join(director_items), - "vod_actor": ", ".join(actor_items), - "vod_content": content, - "vod_play_from": play["vod_play_from"], - "vod_play_url": play["vod_play_url"], - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - raw = str(id or "").strip() - if raw.startswith("push://"): - return {"parse": 0, "url": raw[7:]} - return {"parse": 0, "url": raw} diff --git a/py/奕搜.txt b/py/奕搜.txt new file mode 100644 index 0000000..1431818 --- /dev/null +++ b/py/奕搜.txt @@ -0,0 +1,15 @@ +// ignore +//@name:奕搜 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:ME+7eWAk4mi+rQEE +//@ek:base64:4/51ltr+t+gInSfgPvGYMd8egL/ICedla2NVx9sNehz5lKUWg2BqWvdxHoDRhvzM +//@hash:sha256:f62716808832ca5528c7862c02f44f63938f19c8e57361effba61189d27d6335 +//@sig:base64:fq39vqWVzKwz9oJMaD2aYSjDc9tTmZGx/0exCz556gwIT2hdKobkJJd0gmqCT6Tomt1V3aYYQyglak/M6nByAA== +// ignore +payload.base64:o4GlrgclmV/Lx/OIDJ/MmGetJRidWX5dA2dyjyWyd2a5ATFPBQOdq/h5vxwRdh8namchmwVEHS4ng5LqMaf6t2CS5valmwhV9r0N8zgopA9tTRlwo6ZVTSWSNMEV3y6TlqaQva9h3YrP/m8fuBHahHwp7RRJ1NdqXXBY3Nae2dmFPAcAyQrUt4ocbsiB6vmjThkIfKD/bqIHMjdA7pz1+mQYNKh6Bgz0A5BppPjBPXRbtz26BEaQFfUHliuKKG6SOcj3LkFLH1drnCrng4sIU/q2JWwJqU81NcUDLLO5vjManiK0RrLRN/Xw4Y7eR3N3if1bCaFIjtlxOMgBlga18lFMnh2XuJvHuy/15cz6EVLFe5O0L0Qy5dK6ubP0EERk3//0H8nAhokfKSX+M0wMXgyIOVyJyT0yFNxb3yjQorBJQEjtXMKflEuCqIBb7uM7PmMSi1FP4XQCXGSri4YF+WpCj/nPt7tgNxNzFQWgqQavpUJ1aLoDin13Thqn2wjw0e46cMu4AhSk0VFu8FERJIJeigHJY4YiZdJI0nYiPHfRFeHAoNgS3N84h9zjIyAEYMbYtZiTzEcoRz+H0L15aDHOna0H3pTT2beSAdvjUNdrYmWj79xiHmBQ4VUfIsKx1bi/yOi/NdqfYZ3FOG7Rp9SkqyhZK/I6YH1mn3DTcQitmWOhliWHuOgRxkoZv5odBcNCYMI4I+OgkfoKYxanGxGGwcvtZ5A/uOnGbyXHgT/W5N5n1iJC7xHShST5UPFl3JFJBzYXNR/Kn3kx9Udd4cK3UAoqVs317tlUv/gR3npZWef3UOwflNhxHNyDnkSP7666xrbBm9//SEn3bkkSZfWLUlyFk59L5aeNlDnShFtJMola4SV+KtnsbouSEjbHvNPflVJE3/hkgziqzussPtXgQ70E/D/tYWeR/QXXXRciZ6l9iChbImhBt943cOgkDs0Bxrf4yEwl1Xd4UwoHypJH9g3zmKWbJcdRszeiLqwnplAoaPyHsOq1z/LQd6aYue0/tg4sRygQw+JNSzzbUVAyS4GNNAJ5x5mJ2WTmriOM+AvLTAJ8KNRMqn4KeCfoRYOApzGJ2nzLK9UQzdiZWkMD1A6pn6EjHYnlnbQQpaY/WLRIcBiiIPh2RzK964XeMtMrYHvtJihdSjQpaIH9ST7H42OoP3E41v/Dja2qBqwLc0QN9oig/llAB3x7nbD0b5aFzluzwC68Vx1PPWAnGJtW2WDJWPIdp+PurDR9PegN5iWcoc6uqABe1XltqwsPjiLTQD5f55XzIucw/LJI11kea4TI/W9p+XowEUqOUxhUeOOEoK7C4moRPPYrfxVAuG9xbhPAZwCO4PDNYeGANwLDvFhURSfNsdUG5auMB/eGW8VLmxTMY/i25aTxfm0NH5yNGk54VMEsxVzrD8/Xlw/bGE+YCC5ZY05JyEbq34BRYNxEFu9xiRcziUwQnRusx0tZniRd3MPyvsOxtr5cYqwVwLFFWt7lTv18ls9rwmtyvZVd2XmcXIVxyIwiZMrZ6lmkzTSZjTSWgen391rjgW4dCFm6A9z8gMMX9Ffx0eAOa7ju5LKpX3dg5kDI1tJ+vqyGWchm7tl/RR+VIYoEH2Lyd6VjyjViA+xFhHFOTlRko/lFTVYD6VrC0j8Fma59/i4nITNmEhDlKFY+918tqobGqPcA+Um2JwxjWM5IoqsnQuW5T3x87RUs6nnYCppZBtdOi7/cccspdHGaSHtnLPZaiaQOuuw4m7O1puPF0fBzeTFrRdf86TMsIu0CArsBSEKCcoHfMUN0BkNc6NZ30gp5kttxPUWStVWtIIr4sz1bOwn9F6zkV0XFvLOm/+94WcnNSY4N+N7RFkIq78aE4xK+tEU5f2dkFzSQxe0CyQGUWi0zRxQGaj5tsTXeiiqgameauEIxDMICoAKV7g22RA9hzZKtjWfeRB+IehOyAiL8m7NaMmk0+ZiUclk8aSAgGALbnA58B4m6NCTu1vLQqgq1VzyG6Lf0BAdrC4ZHXiAUxE+ITjolVMv3LcjT9/xWMCmai/fk7/zUKip9yI/oda9+eGoRVckubUtb/55x/udSPLnzZHsNc6u1DZA8vvqPEDzyFa8R7gHfJuViShjMUBf5098Rz2uoACJYf16x34HNr8VZa8imlmKwQZx+tJ8s/be9SFx9hd7MLJcnwyuQ3CAB30EHkdIUBwxTal+3i6ii8kCNdeWy1kZFmY1acwakO1tUuNAZnF9/9pMgflGo3w38sDqNAK8ABbAGVT66y48w7huCmnS1n9lec96SI445lTpRj0GMAsssFBZlhPu7GgI7tfjs9dsWuaaW6E7l6tF7fQcvaaKWd6GaxSHgVkX7U4b3X1zGLedOSSYYs19bEfyMDC1yNTkx9tj69U9z3QXnkqoYko/80q5l4W+SRU9UXw3g+KiWpMdo3tqwTCd2j3dO5Br/UflpxK61aOoiHVMQbvqFIU3+MLslcajKKLAWQq5PMHx273iPkSR59MS2aXgC9pvFZrMOGbczxvmWYpwEQF6DH3bHp6cIL24ar9BQLTBR/fRH+yixyFrYXyansMZDJ0TSFKqp3RV6ujiOmzx7TA43vlJHRoM/ntmmc+NJwDShqOWRg1APcRcxzzxJRTF63QWHXC18359ekAjXxQuXiF6ncCnLKyMzIwyK1QH89Kp7mSptBOsgt/r7qvc1Oh1h1DKGYrvwZ49C5jmVhrijerjaNiu3SG2CfUIBvfdBVRuKUdD3ZrUn13egpK48Mg36j4Mq/hw9m7WjsnbUe76r65lX8tSMHwdw+Ao4W3Bz+B3TceIby6QsazRmfGS/9ep1xWFHARXiiDp5PMneG7ZXow8y2SWj/q1SMzYAeUqh3xXx5myE6oiaw7NWMD1jq6JHPrS8cla9ESB7FhOEbVOOfax9FAaTYCGOZCvZzW5L0FEw8CUo1wAI1B/5V8oWEcJ6FJllUubtWMXb/I94FeGkyKFleDduaD3A5Xa2cyTRsPqkH36CKcse94ZWVIwQH/He8FmoybnIJ9zxuHg/0rYSJIscpW4awyl4UIfE4JFcK5+9txSYd7AFuCwxDvMe4qTs1GyiKa5bl2oEVKACZY5CJovwPGPO9y4s0acCTrI9i5J45Arn0iY1I8tNAW7+8k/ZmR3tOK3u1IvgwqVsxB+ThHLSdOlASolj0ESQikOsuSbSeI3BfhgIHdt2fpRlOiHMKKL8ySxYCqnr0V+Itslg75HV8B2Bj28O6JCvB3FxWMgyEWFSWubkWmgkh9BY6bS2kKVFZMms9ongQDeTmsx5a5JT0VQgedYUcUIQc8R8ms7MPova/EQCmukvpsi75eUaTlQxUuBd99anY3PFpBDnreMVemUZpFutGnxwPeKDDguk2anYbvF5SJ0G747d3cUpcxeN3G56YjKBCOXP6U84gKNXO86YnFjuHlxdKEDcO6nkQBLE8Ob+0GQG8debiTwFkgFgnB9EY8TotTbvGofab/wp6M21mw5tQ3AzJMO8Z+bqfkh6FfKmsfvDn+I2AjH+FvqgmdSyYhd1hJN0MFft99o6x+LCV85H/6RzBjUrRJKBIlDrmyaMe/QYLbPn/e0tsElmTatUm++eI+I4GHBkb5JnwtZ3OpyzK1FemWwg2JNHVBomkM5o0rfy8BsE5DfChpnzBh1yw7cUIbkWT3jagdonzmFcdGToydfihUZDKtkC+qu7XUGLSON/YKyK+HxbhGHOA/0fbqlnc6tV0O3tJKGpSHPgt/Ksmr9WBLcRtkGpNjnuFQXqh3UT6dTWV33QJflaBFwBbVyuF3zXfUjDWmESBoBvR10ukF3CCc8thDsqm9bkxwGzA570dejcaoVrVNRNQFffH1ofuEwfIDTvkQiKFJ52qn1xoc3pjwWBMpqdqO/5BkcJtW4JtlnkILlFTY95tmoXArcwI07vIiBjaIJ/SII6l5kL7+4tqKXURa/yRhTqjPHfC8bqTOKByB5BW36U6se6Xu6ji+wDpew8xxglssVgjoGc0tAywwy55HHt56S1xprnyLmilXuRs8EzeJnweYDU1gbj+Y7J2JVH9pIQEsXVyc4TyapR/gvmrGtrb/ovYMdPrXVyqZvR3rI9KEatfJcDwRZu/KUE91xzlcWlowgRzrqCxFOU2H1vG/bNYjGcUHrpTcVjC7Q6oTiSuI05urFu+qFWrP+xElYRvWpQpqsMLvpVJXDPrrzBGOwWWJ638+f8WF0xQ+aaCibfqaRsCm1VFrXUIZhCiNvDNoPVN4fWEmPotjLIx/tDEvtqNGYgGZKMvh7wiAERjzXVj98qJ4s0POZEYlICfXTxthLH3lNSmS81Q/WEL6dkdN8h6Nq3W/z0o7s0KMcpBo22cushuwgyu62EmiCBpyGp8OvQAlHAEjiXN+ydnxiAj8vKiB0G8hdkUYQZTOW4lFMMGPZmw9MDpgLS7y30ymviqJXspSLJIK7PkcYuvoNlGffsFZzSOcF7ZnAtHbf73HDZx7IrDZfyFUkHS92s89fY3DmYs4s/45xLl3a3JInHUJhgCxQjWlHauP/wp5dYdQKqySPNNPVlXaFAADL5kTJnQd0++aQjCzDW/ADc3VPYC+oWUwKB2OpHUqO2DYKCwFt+gDSvH98a22JxBpC1aFpnLCyR6MnSlkdRV4OMuk53A/NBrRSF1QCVc9o16gNLJ8NbtM+1HKaLolbjcoMcK0LEf/DOMhgV38dFhhcPOIZyy9z8fptEUdb+a3oG9IEAazl6VtoZR5Ms9NbYt8K4cyuDhwblAd6dvt6Fo/pk0+H5rlRyP0IFoIeRWq5TtIMgz95Z5trJT13eeQc3Bliha4hSeuPJZQ5L28Np+cEZ/k60+f/63LQNxXifFg2Xs5QuGcMY9CVUNfqmb0JmwjKybm7jnGwZWQ0oZ9T16+Ege8kndmjmwJ21w6jzc6urxWvEeK8eCHApKQHh4mXzobRdA/qEYOLNVYnX1t6XWRGNSG3IZGpkB0DsF260wQg1wMGTPuRuxbAoRcimllXNaq+qmbLlQLWwfiGinaaxU9F8t2Q+A7irCe4MPt0/jk7yW3vmoHkXz7ydgZ4FbY0LBpPMsAz1IyGjy858d/YoflzxQJcxYQEc763B7U1mUg67JKNnsZ+3L5hwIAGaIy9RgAHR82JhuBV4Jbp+EV2VttQqtFLb9t5nD4MY4Gb7W0vt8/ZoCQwpQSDdvO5nf+2B9/gf8vYRbRseZXoV1jrp/olqKK96wnuYqrKjljv6J1Wd/0OgpkI4cCrmdoID7cfXh7Do4PHxJHdjLQ4RMawuJD5tgCEzu5hnlZ+BpC1rUkGJ5VgWMxJ5PxaK0ZL/Lqk6j9DEJX+L8Gc8VGqTeOOCNz79go6nQ2VqbGvq/VXNN0hV21gb+UGuHzADanQjXm1zUerq7QG4o6ptI2wuRpk9pDQzYBPjc26TILV5zBaKseLgnl2oUnHnnZ4Ps+VbiwEfYy1oUN2PS9Q3PNx8ixV8LP1fnJRvOsXKqVMxfv5X/51np2ngjc5hR/BTcd51LtVQPDJnFSzRop44Z2MvpSX1BYn6wkA/HsTCrpdqyzjaWLLL5QT8zBcvbwHm9FE0PvG6Uz5PenHjInYhWo3C82B9pJ262x8FtqUyx62g3G1f/YfWjwMds3cuCWLVgkAZbhxCyQMwErF8LiYuJSOpCI2Nq/hg2G+igXbWVcCfwYFxsy/zm0UVu2Em9wUWhAH97dk3Kcg1BmIC0wicHMLFuW50a0zbDDD8wF4wuDaJrjuqLhGZnH3lDWVjXDMwj8YfXfX+gPXj4An5/3YJ/6pO1s3FzswP/F/GUrwrntBlVg+YAWSbm3SQXo+tllT4obbNnen4OkZZ9moK53zTeSGZ4VBQgyBy93kACHAD6OH/N4Xwz9y+J/SeTZ633QPncj2Jyefaaq3g+1SALZxUo1OUtAMhg5ZMzGL7c5GKirS8MobJpJ18kF/sWt/yFQ66WkYWgLcHxTWJH3gUY4QUWjkzwyFnOMfkPGzIOXELH2Z+GPWOBTEJFRo1BvfN1OQwz7Cd4l/RNA8YKw6s4ggfjMVwdgNnYejU2RXOO3sLAISf5/+PYgBhiaY/YsbnYpnuzAAs6Bdbvdiaua4U0Iam6yCTutBdg80p8uo0YjOgjYEcXsLJ6yFURQHg0QY+tHNgURi2Ys1Kcm+GyN2yq72klyHZqoZxrzv2R8JXT0iPAWsI4tGKQION2RZYLKlsiLtcP+fz3AEssR6px5EKlzAIglUE1Rl4mZ4O1q0oFaOvzJuROzOPqa09SpYRL52DT2qjk++eoLZzrH+lNKpiz81thZC4bY6Py8hO0fHXQfp/jgVjRV2Woe+xEU2jq06V+FeS7HD6BtRKE9oNoqSCfFL4m5K77DRzg9SMZaatLOT7EOJhYCupFHDzVOhkoWmVMTI5MjniFqI35H6hcecXpZnG7hahUrlNi7YGBR8GEnAsugNUlkjykPG4cGm/YfjiODJQRhqLU2xk0SKtzxkR5aOzOQtxv0b/jF7445+BHkSLpfFs8NTGgfcLn35vqXVrR2QwYyS1ObewPC/zv7nZdXD0cwuFYLqOco1iLGIkMJ9oPbAcgJLQk4nHqvTCGesYLmgc/HeGBdtwW6mw1OhQzuFo94lYoBOh67FR4s6fcjekdpoWqPRxB0RBgTtNQDGS1pPrYToh/uDbKP2PhilIcf24EKtPNTfPNy+sDycL3LrzpOxqqYwU5sbJBNCQfuTOUDOYtEniP8CMAcr2w0kCdiYesHfTbdvNyFIGFnq8jjvCOAyNUY7KeGLmu95tPboQBJcULZ0A89WjxdLay7/OzlaNd0qOr4AazLU3+P/S4WvRpkFoU1hUYClkKvCmGHhJr3S4QsQQ8hoy/s+TimMm119dcL3tEVo11pTZOR+VV5kNgVTTmkyI0gpvwfTi5nuj0+Y9t/DhknGg94W2Dyhbm0qBou/9fAP8W10mRzz2jjYikY82R+45uKoGyp2QAAg65uPdsWjnfvkGa3uySN+OKNEM/V/71hvlRKel17pIoO/tfMISGg8IGPr3x1+seN5c7tVs5m/ljReEJZSCBufnKPKRa3nrZk1oU29wUhrr3kGmkj8t7CNuCya2yreBYFNRjlOowwIKzLpXT0UMdsetVxoI1iifdeF2Jm92ahp7mTTHTwHyoy3Nj4eceU0ilx8ZsLqcYOlPG42PGHWhI06MvsojKF92Pbt+h8ChIqbnQdJynKNhMpy7hQjK718C7f8EY+dqEB+AFKtsc04B2l0de/5WPnU0kt0KxZwoUcmhubErpGRvgjY/1o3ISx+ClWO/8uAfLfzrk6eJTOgm3jS2L6ZsYf3rkpW098i1TbCEQ95JGJ2CnEF7T1jnuEl42BYRmiIdXo+LdQnUBufswXuySxumexOIK4RvwyX9uc4SnS0x+QHYNb/LWaBzuVPmMP7jWCADJVVR9ePHQXNR1pcy6Cq2vA8EgC00QIJ4YY5ITYiTMj8XHkakt5l7WXE02c9H9IpIx8v5Jja1ZyWWw20pQwm8VQaszxw+M7zTOCetL0HQUucjnjN+zIuCjTSia2jjN2tLrtAx0G9Mlqo2xxUm8nAOQI8to4T5RmxuI9WVQTO4tgx+JRL88F+doTdanmpKe4BBFI6TAtKFOqucW/bMJe3U5Orlh7/+nJ74oAuifdRXw/dIZ6H1Z2cioga8l9YX3WWCGR3qx2Re7MndaiMkFrhacdykKojG7SHGuLPACrmggfFc2O9XC3/hzr/lJRPngxOgZ3XIa4WcLelqO3TIWxbzSHGCYZpEWYD68KjyTNmfz/c471AgrxkrmRJcvsyFQzu6L5+CzRSC9PCYfCIqnupRnp8Ao2gs/cBjUuJN5hyap1QzG8nX5nTVyENXjsr8q97VzUqjayzFNW6LUeNckjnvWRQ5aLWdm/FL7jViJ4ycCHa+PCUmcQQAammfXSsGykHC9MhQ3H+/BzpWVvLEI8DkdoYQMCs1oYvGM7Qx6DdLVAGMGOf8dk9GXWeg8JYyaNMFkoRXCKFQLDmhcQv0rmqSS1Rn1IdH6xBvP0B3G5ze7sBGbNEKRpO0oU3xWyQ0vh2cUK0QiF0azwioI9VoPeUuxcLfsCp0J458h2HzXN2Hx547NvBlNX1+pky05SUiaPOkVhuhNq10HsEb1xqoYlje1Z3iWBeTOzSgoqlcJMoxFid4aFEcd0QRG+wcNJLpo+huKtSIw+uB2XVHZSy7YFIjZzdo/gb+0fNlStuBxsEvQ8a4VrZfxJI2oRJP9gVYbkB1syKiyXfHsqHaa4KfR/JWkLpchP5STovVFJKLCjOCGXLJ5Z+bCd1DCaOJxd7STQ8cEXF2DQAYldJo2YKBofgipC9medKQr4CRdI2IKZjUMUhUuyaiLgfoNFgzpbnUDmDXcQs9mSqlvImgIXFn0bf7mZJ1mveWjUNn7kO68Uoh1pTEJ8+tlAav7pyk/AOKrk/oEpfOpZVYMFLsuqC3NgZ3j5ByyzxunTYx4otrB1UZN0jPzQqXn/nCo88JxA+CMHm8t/kpiImuszjGVIGimMUBoJG6ChyBf980Rw6sBQzgW7nJv7lg4ZjpLCdh2g4bg57vnD2ptRbCQYNLP8CFcv+dxJhfgnvulu42iF1KdH7jOMS50m9TItD9NupDXtHofX1sDIZKALw1gfGkpYgfDOpVvwlGKnl3yXiOT8VWC1/26WHYdgn6E5eF7/X3+9IGP45mwm5g9bhLoLPfdVA+Wbz2GxbiVEElCOqDTSg50BYM/umLYJAzRB9qV6lM3/eLwmIRJIjEV4hoU+n2eKdoUq1wCSJE9nycoOt0+sTA467n2n3D/uta9LY5TBrYcm3dZgmTHqXwJt71waNPJZsYtWGgWs24K2A6W/T83f4pVvXv5PPCoBvwI47H/6WG9yJWx/KwtdUocVVlimBSYdx1UeBwoSJc/FkT0q9dJnneqV5nAzJg3pxNyLoCYLNab9VjsbWd2xDLqe1vP2JAoUS1w2Gg1/54f6HCKKZeeDRSDU/tOi7cLtnC/6r5foWjOavjtfF45+zBx3YN7RCwcgmz1WoY5FgcYhHBiYpVttogujfeGKnJ5s6VU+VRLdd23J9qqTxWjYUa5SL6csz+TO9CUYzQAVzzs5va5boyAirhKGgD4JP2WnSIFyDFrIGUnEnxRzdhx14E4IpvxnDIp+gMZYA0FsT9kwQxID72uBkv4ZPBJI06tT2XPUCBqzC/BfP2VpDuC/GKQhd9snV+fvCWMg0Wvw4YMWRNj62yHrY0ZTNbTo4CZZSCaf0Zfvpml0YLiDo0dx5cQg2ZWz+XztyM6+/VTvRpQnBth/8X94er1dSsZVdr4q7SS+sv4F1DeuKePGWE0TgDyKFkqEBJuGzBwC/1LB1nJcegwICsY+YOKuzu7lqyvToi1JR71XvV3avA4le4gB5fIVkl5wtanseQHjBIVXxydWg6uEUoeJ0EPdB21adx94w227Q0QTaFgl4sqgQmXlPPDVE01kTwE3aIumsSpb3t92pWF90hPzhTEyZoyAQUG5rK+gOhKyfr7c0dq//Ez3943DlHSGYa94SGk5sqlWTNickm3rg6S1crrU0UuWNTQuwQpztRxRMY1Vm0hzLSneMHOSEjGck3+/cAdMf5EZbH9hSN9+XbUQvp5AUazS8Nq5y2N+cOq/fW1EK3xefUiVLwt/TErH121+U4ZsFSuhZ6fc3dHOJT52ech3M7xOcrwZl0Gt4ZEAMmBEP9N7mMCS1hm0cS4jYzzJkwl3Wnmpt1Tq3/g+b8k2c9jf9YpKQGJtGLzFqVbz2JWPD54chtirJ2CRHDEYtgwCtoQTfKsYA6b+kiWzjKV240zfXXtaKv5Lc2wlIyDV0cME9uVpnKipapEg5gmpx9ElAaq5fl9cQVHFC40WS0Ue2Ak8GE9ZBxvcCi6A+INZhtfIWJDvZ37OX2PwT08imUEVBni0wF2D+wxGUSjK/bpbLCxmf/4kre7Z+72A5iVNqwBy19vzn+B5WEddTMVVwV7JqsAAQLx8+orc5DOkfJYv9eiXFqLDm6terli2dRQlhKThkwTZwePDVVug5366HdPrIV5I6imQ1D7FBQrzr6Nafm+AQdtHy6YueUjqdKFlk88I+2vmpgQiVDvvq3pTwUucRUMZDLZF9gdDN/van0W4r+OrxKiZchiYY464dMhXOyfKS+rMNM0tI15o9okY1NUqWTZ7of8Srjq4jTJ1rll+ij33Tz/f7QPci0m6sPwhmtnwd7x/swJ7bxNTVs9yxM3w6MYk9JCaEwRz0z2d7hhc9TPIFMVNptOSl88kLuloENm8z1+6942MbdJGcrO6a0ZZCo+o6E7u9ZtBhF4ffLLNqVj2oQemDTiBAaZEq6o+aGOGbpsCLw1PSNEL9D+ZM093RMrnJ3GrlmT0/oDW/agOP9F+4wEzp9P+z7rabvtNUhbwoq9K+datUUo6Yf5uwnNFMhpjzUc4qZVf+TuEda53pi8siQt0cblGAQnIazJEuBYLTzlqB9nuEVTg95JnlAvS3YHkuswkQfP5qK0SBgaGEcvk8eWPj+YWXwL5kpXY03bxSs5FydJ8kKNX45CVk5g3EYEsitrkI2DZ8iA1aoYexr+D2hFNwFmTAaULB+EZtEw21DzgOo6f+2L9alUo6AA3eLDhlxhbZ+m1OQOpO8IpNG4rFhBzfnuNzd/ft8DPNpT7bpaWIlly3+0+5R0L7fFQ06gvO5vcx3JfUYakqq212gDlRoi65bQzs1h/gSz+xW1BZEdkbqTGLz18I9uCwRVSZ/T3wlOHE3rvNJ68iZWDmTICKzXIgKIBR86/Z+J3KnNjb8sVcmV6fPBEUBeDR+xqzV4bvBdkz+5s3IC6ymWPwNkTMW7VHeoycsPF3ShifbChPI8rvy4kD9/umtRus+TadTAnzJWy9SXRDA3DWFF6ZY3jRH5jq0yW1WIepc9TK0yiicweh3sjrLwH4GxXEKoKqKqewKH0tNAghTnYyWO9RND6hnLquktb4zvFxtArbhpM3RysRAsLazv7CStPWvdkcXF1lwn+GYvonVfwQrFITA9gvXL6P7uB1auWVL0kG0q3pm2AfcEvL/vSP4Jwhe8ziATLXDwiXrRlBx+bnPtDl8dNkaxpBx+SegQ5HEgO7AoXxazcQRCvge2o0CQuo+4XMrI6yha0mxex5J2AikNp1tTxaBich/JbAt8Nv/MM8yWM4aAWJrgZC+m4zDnPlKk48/HgZA0RJea3dLsT0Nr5rAqUSFmn6xg8Lp0KjDuTYFc6QoZU2W8EcctWQeDy2cJGHPjlEDvklQPsq6csGMJsvLHkjRrvvjDbcLRwDVxNYwtO66GhTx7FYCaOarnx1uRhPyt2aFXZkvdQ7Sll2Ci09JCDVN7AF7YHBJOKZeKNHxkOYgG8cHgaWQ6tNB4Wkg2afit1Yoys8t6BIJFsQssaAAqeXggiZHfGfe3UaRRzWgIsUnZnXqTjUg1MPRIEsTSg324kZCS8idCCvCYnggBsI+qb3+KgotiP4p0li3adJ30iZ0zjteXrTQGyaamr9l7meouPnH4m+k0S2+1eKW0toMkeGHizFbFq2TMOM5JOqY9qSz3xi4iQVYEm3yZzwA+R9dkgPKIR3RSeYo075L1MSf1Jnn3nThkfQhhydhPZPpisDdMAxhFV+3QZ3IsctbGBHgw4Rbocjloj8JJpeppfB8k5Rjvp9tYd/mc3cLp3/sd87yTxJcI6CnfuUhMmU6myH+xNI0hZvvQBrzKwcW63b52SoDJ7xsIzDxxAbD/4cnJJOhZ/XG0aThyj9voHCBILnqx7G3g13CCoRZhLsYQKjZPVakZ0sTPWsvppkNTQ9OdgCx6IYWmFEIj5/8llgUFaw+AO3ryUyfwt3r1ws30WL0pgMKG7cKANLFhYB1Oq1JqjU5SmVzUzI6ECnnsfch8dLWH3Xv2CrYLoV4avUy9rD3JTlaDDSy36y4QBW75L+aQUXpQlTR6ULt5sZHvQ2mheAshSpkkuW4lvLyMg3UgrKlTDvnGp7u/uM9BzLME2n8fMyHRSZaSxW0BDGEHp6V517T8sfoVxTC2YSHA1njAr6SEnbCm8HLXmon1r0PlXBn5uSM10tjPwCyKganAlYTwSRhPPrzyb3x/NkB9kyHsdq7V/6bO2a8R3EeU5TjGyXr/8CO2RhdgwZZk7kDPnUNdqP6DhFiA90uibLjmx/ITqb2oAvtEJCBQwTkRszxXmM3KbzwF0giR+NiE5kc1v6d2zk6XVoTKB0rGDF2R4e/gVs3N4rhnMoIuS0Ngrki37vikDz9bYcxbLbdH/pXNHbwbWs9MtpXTyEgUJthi/ahSjFCvqrBiOUWUr5aexUfhipIWeKa3m/PDW5KvuV/eir+xEao9mdIxrSg+QuM0PWIboRmialnLykv/kAEeE+yIK5GtweYyaghLM+7UfPX0/QuKZqNopPF/hSLELzSjmn41Of1OaYNACeUhiAHx9kbObRFHb9A0U2b1OpQve/F7F6o9ZCo6kptLB0ogGyQRl3CpEgx6n8JrIK+o/0vQ6+cHMdZsum2F+ZUB0jLCAvTJDM0pkXYWF/HHy56wySEpWurYq2vlvIJom3Lmif9N8DoZLd2LB3ZPgzpn7POAOkgYMR6Nx1GWhE0CnvQc/bw/wZcYFiYC7DX9fY+Ev9+HUTX5A== \ No newline at end of file diff --git a/py/如意资源.py b/py/如意资源.py deleted file mode 100644 index 863c682..0000000 --- a/py/如意资源.py +++ /dev/null @@ -1,295 +0,0 @@ -# coding=utf-8 -import json -import sys - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "如意资源" - self.api_urls = [ - "https://cj.rycjapi.com/api.php/provide/vod", - "https://cj.rytvapi.com/api.php/provide/vod", - "https://bycj.rytvapi.com/api.php/provide/vod", - ] - self.img_hosts = [ - "https://ps.ryzypics.com", - "https://ry-pic.com", - "https://img.lzzyimg.com", - ] - self.headers = { - "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", - "Accept": "application/json", - "Accept-Language": "zh-CN,zh;q=0.9", - "Referer": "https://cj.rycjapi.com/", - } - self.classes = [ - {"type_id": "1", "type_name": "电影片"}, - {"type_id": "2", "type_name": "连续剧"}, - {"type_id": "3", "type_name": "综艺片"}, - {"type_id": "4", "type_name": "动漫片"}, - {"type_id": "35", "type_name": "电影解说"}, - {"type_id": "36", "type_name": "体育"}, - ] - self.sub_class_map = { - "1": ["7", "6", "8", "9", "10", "11", "12", "20", "34", "45", "47"], - "2": ["13", "14", "15", "16", "21", "22", "23", "24", "46"], - "3": ["25", "26", "27", "28"], - "4": ["29", "30", "31", "32", "33"], - "35": [], - "36": ["37", "38", "39", "40"], - } - self.type_options = { - "1": [ - {"n": "动作片", "v": "7"}, - {"n": "喜剧片", "v": "8"}, - {"n": "爱情片", "v": "9"}, - {"n": "科幻片", "v": "10"}, - {"n": "恐怖片", "v": "11"}, - {"n": "剧情片", "v": "12"}, - {"n": "战争片", "v": "6"}, - {"n": "记录片", "v": "20"}, - {"n": "伦理片", "v": "34"}, - {"n": "预告片", "v": "45"}, - {"n": "动画电影", "v": "47"}, - ], - "2": [ - {"n": "国产剧", "v": "13"}, - {"n": "香港剧", "v": "14"}, - {"n": "韩国剧", "v": "15"}, - {"n": "欧美剧", "v": "16"}, - {"n": "台湾剧", "v": "21"}, - {"n": "日本剧", "v": "22"}, - {"n": "海外剧", "v": "23"}, - {"n": "泰国剧", "v": "24"}, - {"n": "短剧", "v": "46"}, - ], - "3": [ - {"n": "大陆综艺", "v": "25"}, - {"n": "港台综艺", "v": "26"}, - {"n": "日韩综艺", "v": "27"}, - {"n": "欧美综艺", "v": "28"}, - ], - "4": [ - {"n": "国产动漫", "v": "29"}, - {"n": "日韩动漫", "v": "30"}, - {"n": "欧美动漫", "v": "31"}, - {"n": "港台动漫", "v": "32"}, - {"n": "海外动漫", "v": "33"}, - ], - "35": [], - "36": [ - {"n": "足球", "v": "37"}, - {"n": "篮球", "v": "38"}, - {"n": "网球", "v": "39"}, - {"n": "斯诺克", "v": "40"}, - ], - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def _build_query(self, params=None): - parts = [] - for key, value in (params or {}).items(): - if value in ("", None): - continue - parts.append(f"{key}={value}") - return "&".join(parts) - - def _request_json(self, params=None, url=""): - if url: - targets = [url] - else: - query = self._build_query(params) - targets = [f"{base}?{query}" if query else base for base in self.api_urls] - for target in targets: - try: - response = self.fetch(target, headers=self.headers, timeout=10) - except Exception: - continue - if response.status_code != 200: - continue - try: - return json.loads(response.text or "{}") - except Exception: - continue - return {} - - def _get_pic_url(self, value): - raw = str(value or "").strip() - if raw in ("", "", "nil", "null"): - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("/"): - return self.img_hosts[0] + raw - return raw - - def _format_vod_list(self, items): - result = [] - for item in items or []: - current = item or {} - vod_id = str(current.get("vod_id", "")).strip() - if not vod_id or vod_id == "0": - continue - vod_year = str(current.get("vod_year", "")).strip() - result.append( - { - "vod_id": vod_id, - "vod_name": str(current.get("vod_name", "")).strip() or "未知标题", - "vod_pic": self._get_pic_url(current.get("vod_pic", "")), - "vod_remarks": str(current.get("vod_remarks", "")).strip() or vod_year, - "vod_year": vod_year, - "type_id": str(current.get("type_id", "")).strip(), - } - ) - return result - - def _enrich_missing_covers(self, items): - missing_ids = [item["vod_id"] for item in items if not item.get("vod_pic")] - if not missing_ids: - return items - data = self._request_json({"ac": "videolist", "ids": ",".join(missing_ids)}) - cover_map = {} - for item in data.get("list", []) or []: - current = item or {} - vod_id = str(current.get("vod_id", "")).strip() - if not vod_id: - continue - cover = ( - self._get_pic_url(current.get("vod_pic", "")) - or self._get_pic_url(current.get("vod_img", "")) - or self._get_pic_url(current.get("pic", "")) - ) - if cover: - cover_map[vod_id] = cover - for item in items: - if not item.get("vod_pic") and item["vod_id"] in cover_map: - item["vod_pic"] = cover_map[item["vod_id"]] - return items - - def _build_filters(self): - filters = {} - for cls in self.classes: - tid = cls["type_id"] - filters[tid] = [] - values = self.type_options.get(tid, []) - if values: - filters[tid].append({"key": "type", "name": "类型", "value": values}) - return filters - - def _resolve_type_id(self, tid, extend=None): - current = dict(extend or {}) - if current.get("type"): - return str(current["type"]) - values = self.sub_class_map.get(str(tid), []) - if values: - return values[0] - return str(tid) - - def _page_result(self, items, pg, limit): - page = max(int(str(pg or 1)), 1) - return {"page": page, "limit": limit, "total": page * limit + len(items), "list": items} - - def homeContent(self, filter): - return {"class": self.classes, "filters": self._build_filters(), "list": []} - - def homeVideoContent(self): - data = self._request_json({"ac": "list", "pg": "1", "pagesize": "20"}) - items = self._format_vod_list(data.get("list", [])) - return {"list": self._enrich_missing_covers(items)} - - def categoryContent(self, tid, pg, filter, extend): - params = {"ac": "list", "t": self._resolve_type_id(tid, extend), "pg": str(pg), "pagesize": "20"} - data = self._request_json(params) - items = self._enrich_missing_covers(self._format_vod_list(data.get("list", []))) - return self._page_result(items, pg, 20) - - def searchContent(self, key, quick, pg="1"): - keyword = str(key or "").strip() - page = max(int(str(pg or 1)), 1) - if not keyword: - return {"page": page, "limit": 30, "total": 0, "list": []} - data = self._request_json({"ac": "list", "wd": keyword, "pg": str(page), "pagesize": "30"}) - items = [ - item - for item in self._format_vod_list(data.get("list", [])) - if keyword.lower() in item["vod_name"].lower() - ] - items = self._enrich_missing_covers(items) - return self._page_result(items, page, 30) - - def _parse_play_groups(self, play_from, play_url): - episodes = [] - for index, item in enumerate(str(play_url or "").split("#"), start=1): - raw = str(item or "").strip() - if not raw: - continue - if "$" in raw: - name, url = raw.split("$", 1) - else: - name, url = "", raw - name = str(name or "").strip() or f"第{index}集" - url = str(url or "").strip() - if not url: - continue - episodes.append(f"{name}${url}") - line_names = [value.strip() for value in str(play_from or "").split(",") if value.strip()] - if not line_names: - line_names = ["如意资源"] - urls = "#".join(episodes) - return "$$$".join(line_names), "$$$".join([urls for _ in line_names]) - - def detailContent(self, ids): - vod_id = str(ids[0] if isinstance(ids, list) and ids else ids or "").strip() - if not vod_id: - return {"list": []} - data = self._request_json({"ac": "videolist", "ids": vod_id}) - items = data.get("list", []) - if not items: - return {"list": []} - item = items[0] or {} - play_from, play_url = self._parse_play_groups(item.get("vod_play_from", ""), item.get("vod_play_url", "")) - return { - "list": [ - { - "vod_id": str(item.get("vod_id", vod_id)), - "vod_name": str(item.get("vod_name", "")), - "vod_pic": self._get_pic_url(item.get("vod_pic", "")), - "type_name": str(item.get("type_name", "")), - "vod_year": str(item.get("vod_year", "")), - "vod_area": str(item.get("vod_area", "")), - "vod_remarks": str(item.get("vod_remarks", "")), - "vod_actor": str(item.get("vod_actor", "")), - "vod_director": str(item.get("vod_director", "")), - "vod_content": str(item.get("vod_content", "")).strip(), - "vod_play_from": play_from, - "vod_play_url": play_url, - } - ] - } - - def _is_direct_media_url(self, value): - raw = str(value or "").lower() - for suffix in (".m3u8", ".mp4", ".flv", ".avi", ".mkv", ".ts"): - if suffix in raw: - return True - return False - - def playerContent(self, flag, id, vipFlags): - play_id = str(id or "").strip() - if not play_id: - return {"parse": 0, "playUrl": "", "url": "", "header": {}} - if self._is_direct_media_url(play_id): - return {"parse": 0, "playUrl": "", "url": play_id, "header": {}} - return {"parse": 1, "playUrl": "", "url": play_id, "header": {}} diff --git a/py/如意资源.txt b/py/如意资源.txt new file mode 100644 index 0000000..3fe6f5b --- /dev/null +++ b/py/如意资源.txt @@ -0,0 +1,15 @@ +// ignore +//@name:如意资源 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:Ih9+uHPJXw/tEqsF +//@ek:base64:f1VFMp12IS1RllWOKPr9U90TfKjAe1MuEWyp1Rnhpb0UbkoMuwtJmP12hdVFAJ51 +//@hash:sha256:14e0fca1427e6b24c91db9bf44d8c61619aef9dcaeae47e35661469116238ce2 +//@sig:base64:eLQYjzhsrI8lQA5PGcBqb0wCICDVFO0BpsJIpsM31dZdUf47CFYKMcM+2cUvXUOEJ65K2gcnkmrxqMcLAqyfDA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/布布影视.py b/py/布布影视.py deleted file mode 100644 index 516db28..0000000 --- a/py/布布影视.py +++ /dev/null @@ -1,533 +0,0 @@ -# coding=utf-8 -import hashlib -import random -import re -import sys -import time - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "布布影视" - self.host = "https://bbys.app" - self.pkg = "com.sunshine.tv" - self.ver = "4" - self.finger = "SF-C3B2B41F6EFFFF9869176CF68F6790E8F07506FC88632C94B4F5F0430D5498CA" - self.sk = "SK-thanks" - self.web_sign = "f65f3a83d6d9ad6f" - self.x_client = "8f3d2a1c7b6e5d4c9a0b1f2e3d4c5b6a" - self.current_year = time.localtime().tm_year - self.headers = { - "User-Agent": "okhttp/4.12.0", - "Accept": "application/json", - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "剧集"}, - {"type_id": "3", "type_name": "动漫"}, - {"type_id": "4", "type_name": "综艺"}, - ] - self.filters = { - "1": [ - { - "key": "class", - "name": "类型", - "value": [ - {"n": "全部", "v": ""}, - {"n": "动作", "v": "动作"}, - {"n": "喜剧", "v": "喜剧"}, - {"n": "爱情", "v": "爱情"}, - {"n": "科幻", "v": "科幻"}, - {"n": "恐怖", "v": "恐怖"}, - {"n": "悬疑", "v": "悬疑"}, - {"n": "犯罪", "v": "犯罪"}, - {"n": "战争", "v": "战争"}, - {"n": "动画", "v": "动画"}, - {"n": "冒险", "v": "冒险"}, - {"n": "历史", "v": "历史"}, - {"n": "灾难", "v": "灾难"}, - {"n": "纪录", "v": "纪录"}, - {"n": "剧情", "v": "剧情"}, - ], - }, - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "香港", "v": "香港"}, - {"n": "台湾", "v": "台湾"}, - {"n": "美国", "v": "美国"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - {"n": "泰国", "v": "泰国"}, - {"n": "印度", "v": "印度"}, - {"n": "英国", "v": "英国"}, - {"n": "法国", "v": "法国"}, - {"n": "德国", "v": "德国"}, - {"n": "加拿大", "v": "加拿大"}, - {"n": "西班牙", "v": "西班牙"}, - {"n": "意大利", "v": "意大利"}, - {"n": "澳大利亚", "v": "澳大利亚"}, - ], - }, - {"key": "year", "name": "年份", "value": self._generate_years("电影")}, - { - "key": "by", - "name": "排序", - "value": [ - {"n": "最热", "v": "hits"}, - {"n": "最新", "v": "time"}, - {"n": "评分", "v": "score"}, - ], - }, - ], - "2": [ - { - "key": "class", - "name": "类型", - "value": [ - {"n": "全部", "v": ""}, - {"n": "爱情", "v": "爱情"}, - {"n": "古装", "v": "古装"}, - {"n": "武侠", "v": "武侠"}, - {"n": "历史", "v": "历史"}, - {"n": "家庭", "v": "家庭"}, - {"n": "喜剧", "v": "喜剧"}, - {"n": "悬疑", "v": "悬疑"}, - {"n": "犯罪", "v": "犯罪"}, - {"n": "战争", "v": "战争"}, - {"n": "奇幻", "v": "奇幻"}, - {"n": "科幻", "v": "科幻"}, - {"n": "恐怖", "v": "恐怖"}, - ], - }, - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "香港", "v": "香港"}, - {"n": "台湾", "v": "台湾"}, - {"n": "美国", "v": "美国"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - {"n": "泰国", "v": "泰国"}, - {"n": "英国", "v": "英国"}, - ], - }, - {"key": "year", "name": "年份", "value": self._generate_years("剧集")}, - { - "key": "by", - "name": "排序", - "value": [ - {"n": "最热", "v": "hits"}, - {"n": "最新", "v": "time"}, - {"n": "评分", "v": "score"}, - ], - }, - ], - "3": [ - { - "key": "class", - "name": "类型", - "value": [ - {"n": "全部", "v": ""}, - {"n": "冒险", "v": "冒险"}, - {"n": "奇幻", "v": "奇幻"}, - {"n": "科幻", "v": "科幻"}, - {"n": "武侠", "v": "武侠"}, - {"n": "悬疑", "v": "悬疑"}, - ], - }, - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "日本", "v": "日本"}, - {"n": "欧美", "v": "欧美"}, - ], - }, - {"key": "year", "name": "年份", "value": self._generate_years("动漫")}, - { - "key": "by", - "name": "排序", - "value": [ - {"n": "最热", "v": "hits"}, - {"n": "最新", "v": "time"}, - {"n": "评分", "v": "score"}, - ], - }, - ], - "4": [ - { - "key": "class", - "name": "类型", - "value": [ - {"n": "全部", "v": ""}, - {"n": "真人秀", "v": "真人秀"}, - {"n": "音乐", "v": "音乐"}, - {"n": "脱口秀", "v": "脱口秀"}, - {"n": "歌舞", "v": "歌舞"}, - {"n": "爱情", "v": "爱情"}, - ], - }, - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "香港", "v": "香港"}, - {"n": "台湾", "v": "台湾"}, - {"n": "美国", "v": "美国"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - ], - }, - {"key": "year", "name": "年份", "value": self._generate_years("综艺")}, - { - "key": "by", - "name": "排序", - "value": [ - {"n": "最热", "v": "hits"}, - {"n": "最新", "v": "time"}, - {"n": "评分", "v": "score"}, - ], - }, - ], - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes, "filters": self.filters} - - def homeVideoContent(self): - payload = self._request_json("/api.php/web/index/home", headers=self._get_web_headers()) - categories = ((payload.get("data") or {}).get("categories") or []) - videos = [] - for category in categories: - videos.extend(self._convert_json_to_vods(category.get("videos") or [])) - if not videos: - for type_name in ("电影", "剧集", "综艺", "动漫"): - videos.extend(self._get_class_list(type_name, 1, {"by": "hits"}).get("list", [])) - return {"list": videos} - - def categoryContent(self, tid, pg, filter, extend): - type_name = self._map_type_name(tid) - if type_name not in ("电影", "剧集", "动漫", "综艺"): - videos = [] - for name in ("电影", "剧集", "综艺", "动漫"): - videos.extend(self._get_class_list(name, 1, {"by": "hits"}).get("list", [])) - return {"page": 1, "limit": len(videos), "total": int(pg) * 30 + len(videos), "list": videos} - return self._get_class_list(type_name, int(pg), extend or {}) - - def detailContent(self, ids): - vod_id = self._stringify(ids[0] if isinstance(ids, list) and ids else ids).strip() - if not vod_id: - return {"list": []} - payload = self._request_json( - "/api.php/web/vod/get_detail", - headers=self._get_web_headers(), - params={"vod_id": vod_id}, - ) - detail = payload.get("data") - if isinstance(detail, list): - detail = detail[0] if detail else None - if not detail: - return {"list": []} - play_data = self._build_play_data( - detail.get("vod_play_from", ""), - detail.get("vod_play_url", ""), - payload.get("vodplayer") or [], - ) - return { - "list": [ - { - "vod_id": self._stringify(detail.get("vod_id") or vod_id), - "vod_name": self._stringify(detail.get("vod_name")), - "vod_pic": self._stringify(detail.get("vod_pic")), - "vod_remarks": self._stringify(detail.get("vod_remarks") or detail.get("vod_duration")), - "vod_year": self._stringify(detail.get("vod_year")), - "vod_area": self._stringify(detail.get("vod_area")), - "vod_actor": self._stringify(detail.get("vod_actor")), - "vod_director": self._stringify(detail.get("vod_director")), - "vod_content": self._clean_html_content(detail.get("vod_content")), - "type_name": self._stringify(detail.get("vod_class") or detail.get("type_name")), - "vod_play_from": play_data["vod_play_from"], - "vod_play_url": play_data["vod_play_url"], - } - ] - } - - def searchContent(self, key, quick, pg="1"): - keyword = self._stringify(key).strip() - page = int(pg) - if not keyword: - return {"page": page, "limit": 0, "total": 0, "list": []} - payload = self._request_json( - "/api.php/app/search/index", - headers=self._get_app_headers(), - params={"wd": keyword, "page": page, "limit": 15}, - ) - items = self._convert_json_to_vods(payload.get("data") or []) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def playerContent(self, flag, id, vipFlags): - raw = self._stringify(id).strip() - if not raw: - return {"parse": 0, "playUrl": "", "url": "", "jx": 0} - - play_from = "" - play_url = raw - need_decode = False - matched = re.match(r"^([^@]+)@([^@]+)@([\s\S]+)$", raw) - if matched: - play_from = matched.group(1) - need_decode = matched.group(2).strip() not in ("", "0") - play_url = matched.group(3) - elif not raw.startswith(("http://", "https://")): - need_decode = True - - final_url = play_url - if need_decode: - payload = self._request_json( - "/api.php/app/decode/url/", - headers=self._get_app_headers(), - params={"url": play_url, "vodFrom": play_from}, - ) - decoded = self._extract_decode_url(payload) - if self._is_disabled_decode_result(payload, play_url, decoded): - return { - "parse": 1, - "playUrl": "", - "url": "", - "jx": 0, - "header": {"User-Agent": "okhttp/4.12.0"}, - } - if decoded: - final_url = decoded - - need_jx = 1 if re.search(r"(iqiyi\.com|v\.qq\.com|youku\.com|mgtv\.com|bilibili\.com)", final_url, re.I) else 0 - return { - "parse": 0, - "playUrl": "", - "url": final_url, - "jx": need_jx, - "header": {"User-Agent": "okhttp/4.12.0"}, - } - - def _stringify(self, value): - return "" if value is None else str(value) - - def _join_text(self, value): - if isinstance(value, list): - return "/".join([self._stringify(item) for item in value if self._stringify(item)]) - return self._stringify(value) - - def _clean_html_content(self, content): - if not content: - return "" - text = str(content).replace("

", "").replace("

", "\n") - text = re.sub(r"", "\n", text, flags=re.I) - text = re.sub(r"<[^>]+>", "", text) - return text.strip() - - def _safe_split(self, value, sep): - if value or value == "": - return str(value).split(sep) - return [] - - def _build_play_data(self, vod_play_from, vod_play_url, vodplayer=None): - from_list = self._safe_split(vod_play_from, "$$$") - url_groups = self._safe_split(vod_play_url, "$$$") - player_meta = self._build_player_meta(vodplayer) - final_from = [] - final_url = [] - for index in range(max(len(from_list), len(url_groups))): - raw_from = (from_list[index] if index < len(from_list) else f"line{index + 1}").strip() or f"line{index + 1}" - group = (url_groups[index] if index < len(url_groups) else "").strip() - if not group: - continue - meta = player_meta.get(raw_from) or {} - display_from = self._stringify(meta.get("show")).strip() or raw_from - episodes = [] - for item in [part.strip() for part in group.split("#") if part.strip()]: - if "$" in item: - title, raw_url = item.split("$", 1) - else: - title, raw_url = "播放", item - title = title.strip() or "播放" - raw_url = raw_url.strip() - if raw_url: - decode_status = self._stringify(meta.get("decode_status")).strip() - if not decode_status: - decode_status = "0" if raw_url.startswith(("http://", "https://")) else "1" - episodes.append(f"{title}${raw_from}@{decode_status}@{raw_url}") - if episodes: - final_from.append(f"{display_from}({len(episodes)})") - final_url.append("#".join(episodes)) - return {"vod_play_from": "$$$".join(final_from), "vod_play_url": "$$$".join(final_url)} - - def _build_player_meta(self, vodplayer): - meta = {} - for item in vodplayer or []: - if not isinstance(item, dict): - continue - source_from = self._stringify(item.get("from")).strip() - if not source_from: - continue - meta[source_from] = { - "show": self._stringify(item.get("show")).strip(), - "decode_status": self._stringify(item.get("decode_status")).strip(), - } - return meta - - def _is_disabled_decode_result(self, payload, play_url, decoded): - if not isinstance(payload, dict): - return False - message = self._stringify(payload.get("msg")).strip() - if "停用" in message or "稍后再试" in message: - return True - if "解码失败" not in message: - return False - return bool(decoded) and decoded == play_url and not decoded.startswith(("http://", "https://", "/")) - - def _generate_years(self, type_name): - years = [{"n": "全部", "v": ""}] - if type_name == "电影": - for year in range(self.current_year, 2015, -1): - years.append({"n": str(year), "v": str(year)}) - years.extend( - [ - {"n": "2015-2011", "v": "2015-2011"}, - {"n": "2010-2000", "v": "2010-2000"}, - {"n": "90年代", "v": "90年代"}, - {"n": "80年代", "v": "80年代"}, - {"n": "更早", "v": "更早"}, - ] - ) - return years - - floor = 2021 if type_name == "剧集" else 2011 - for year in range(self.current_year, floor - 1, -1): - years.append({"n": str(year), "v": str(year)}) - years.append({"n": "更早", "v": "更早"}) - return years - - def _create_sign_data(self): - timestamp = str(int(time.time())) - nonce = f"{random.randint(0, 9)}{random.randint(10, 99)}" - sign_source = ( - f"finger={self.finger}&id={self.pkg}&nonce={nonce}" - f"&sk={self.sk}&time={timestamp}&v={self.ver}" - ) - sign = hashlib.sha256(sign_source.encode("utf-8")).hexdigest().upper() - return {"timestamp": timestamp, "nonce": nonce, "sign": sign} - - def _get_app_headers(self): - sign_data = self._create_sign_data() - headers = dict(self.headers) - headers.update( - { - "x-aid": self.pkg, - "x-time": sign_data["timestamp"], - "x-sign": sign_data["sign"], - "x-nonc": sign_data["nonce"], - "x-ave": self.ver, - } - ) - return headers - - def _get_web_headers(self): - headers = self._get_app_headers() - headers.update( - { - "web-sign": self.web_sign, - "X-Client": self.x_client, - } - ) - return headers - - def _request_json(self, path, headers=None, params=None): - url = path if str(path).startswith("http") else self.host + path - response = self.fetch(url, headers=headers, params=params, timeout=15, verify=False) - if response.status_code != 200: - return {} - return response.json() - - def _convert_json_to_vods(self, video_list): - items = [] - for item in video_list or []: - items.append( - { - "vod_id": self._stringify(item.get("vod_id") or item.get("id")), - "vod_name": self._stringify(item.get("vod_name") or item.get("name")), - "vod_pic": self._stringify(item.get("vod_pic") or item.get("pic")), - "vod_remarks": self._stringify( - item.get("vod_remarks") or item.get("vod_duration") or item.get("remark") - ), - "type_name": self._join_text(item.get("vod_class") or item.get("type_name") or item.get("class")), - "vod_year": self._join_text(item.get("vod_year") or item.get("year")), - "vod_area": self._join_text(item.get("vod_area") or item.get("area")), - } - ) - return items - - def _map_type_name(self, value): - mapping = { - "1": "电影", - "2": "剧集", - "3": "动漫", - "4": "综艺", - "电影": "电影", - "剧集": "剧集", - "动漫": "动漫", - "综艺": "综艺", - } - return mapping.get(self._stringify(value), self._stringify(value)) - - def _get_class_list(self, tid, page=1, extend=None): - type_name = self._map_type_name(tid) - ext = extend or {} - payload = self._request_json( - "/api.php/web/filter/vod", - headers=self._get_web_headers(), - params={ - "type_name": type_name, - "page": int(page), - "sort": ext.get("by", "hits"), - "class": ext.get("class", ""), - "area": ext.get("area", ""), - "year": ext.get("year", ""), - }, - ) - items = self._convert_json_to_vods(payload.get("data") or []) - return {"page": int(page), "limit": len(items), "total": page * 30 + len(items), "list": items} - - def _extract_decode_url(self, payload): - if isinstance(payload, dict): - data = payload.get("data") - if isinstance(data, str) and data: - return data - if isinstance(data, dict) and isinstance(data.get("url"), str) and data.get("url"): - return data.get("url") - if isinstance(payload.get("url"), str) and payload.get("url"): - return payload.get("url") - return "" diff --git a/py/布布影视.txt b/py/布布影视.txt new file mode 100644 index 0000000..2005377 --- /dev/null +++ b/py/布布影视.txt @@ -0,0 +1,15 @@ +// ignore +//@name:布布影视 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:jEq+n7LAratzZSyV +//@ek:base64:jIVMieZpuA+wvaaqIbypfRdha2jKsf8tb+CiAbTyFO5+/dTysptUSgh9cBluNGG5 +//@hash:sha256:c37419d8664d4f64c7610bc5e88ecc6b44aff3f533e3cf95baf0d655f7fcb2c7 +//@sig:base64:oAx7BLRY31wAx/WoTANu/LiVQchkw4M2ujAGUxBKCW9cfvgXvEh8rHCs13uVQie3CMh0G8HukD7q5L5vzX6tCg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/微观短剧.txt b/py/微观短剧.txt index f91787d..79ab98e 100644 --- a/py/微观短剧.txt +++ b/py/微观短剧.txt @@ -7,9 +7,9 @@ //@wrap:hkdf-aes-keywrap //@sign:ed25519 //@kid:k2026_04 -//@nonce:base64:Vm77/tflIkg3/YPv -//@ek:base64:hdVAe+RAM6d7An2Bcq2PQfjqMRqxT3sTZGqb/3kind8i8kgmoRkUzmNHoxf7LKK9 +//@nonce:base64:ktIwJ+RyQbQkPvUz +//@ek:base64:OJpjkSx9f2PxSga7O74diGjEqYgpBDPPWOV4fW/c93Xrh/1YKl9lnjExngJkGAmn //@hash:sha256:7b193b13b5932993a954afcf852623b447e5899df8351bf36315d32bc802b4be -//@sig:base64:0O/89xOTkPBzzAzctQ9PkFegEiOOMOgGt32cSR31o1DcRUceex/Yg9+bHpwhdDAebIu52BH1yKYGCjbwTXvNAg== +//@sig:base64:w1qd5isrB7LJ2VKBRPoGvNRHTj6gJGR60YRbqzpiiEBRhAbykp7qtCbA1jjrrXGvkTXimGALY4NA5fQjy36pAA== // ignore -payload.base64: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 \ No newline at end of file +payload.base64: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 \ No newline at end of file diff --git a/py/新韩剧网.py b/py/新韩剧网.py deleted file mode 100644 index d449f14..0000000 --- a/py/新韩剧网.py +++ /dev/null @@ -1,316 +0,0 @@ -# coding=utf-8 -import base64 -import re -import sys -from urllib.parse import quote, urljoin - -from Crypto.Cipher import AES -from Crypto.Util.Padding import unpad - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -DEFAULT_PIC = "https://youke2.picui.cn/s1/2025/12/21/694796745c0c6.png" -PLAYER_AES_KEY = "my-to-newhan-2025" + ("\0" * 15) - - -class Spider(BaseSpider): - def __init__(self): - self.name = "新韩剧网" - self.host = "https://www.hanju7.com" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/144.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", - "Accept-Language": "zh-CN,zh;q=0.9", - } - self.classes = [ - {"type_id": "1", "type_name": "韩剧"}, - {"type_id": "3", "type_name": "韩国电影"}, - {"type_id": "4", "type_name": "韩国综艺"}, - {"type_id": "hot", "type_name": "排行榜"}, - {"type_id": "new", "type_name": "最新更新"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes} - - def _build_url(self, value): - raw = str(value or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw) - - def _extract_detail_id(self, href): - matched = re.search(r"/detail/([^/?#]+)\.html", self._build_url(href)) - return matched.group(1) if matched else str(href or "").strip().strip("/") - - def _request_text(self, path_or_url, headers=None, allow_redirects=True): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - merged = dict(self.headers) - if headers: - merged.update(headers) - response = self.fetch(target, headers=merged, timeout=10, allow_redirects=allow_redirects) - if response.status_code != 200: - return "" - return response.text or "" - - def _request_html(self, path_or_url, headers=None): - return self._request_text(path_or_url, headers=headers) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _node_text_without_children(self, node): - if node is None: - return "" - text = self._clean_text(node.text or "") - if text: - return text - return self._clean_text("".join(node.xpath(".//text()"))) - - def _build_list_item(self, anchor, remarks="", pic=""): - href = (anchor.xpath("./@href") or [""])[0] - vod_id = self._extract_detail_id(href) - if not vod_id: - return None - name = self._clean_text( - (anchor.xpath("./@title") or [""])[0] - or self._node_text_without_children(anchor) - or "".join(anchor.xpath(".//text()")) - ) - image = self._build_url(pic or (anchor.xpath("./@data-original") or [""])[0] or (anchor.xpath("./@src") or [""])[0]) - return { - "vod_id": vod_id, - "vod_name": name, - "vod_pic": image, - "vod_remarks": self._clean_text(remarks), - } - - def _parse_home_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - for node in root.xpath("//div[contains(@class,'list')]//ul/li"): - anchor = node.xpath(".//a[@href]") - if not anchor: - continue - item = self._build_list_item(anchor[0], remarks="".join(node.xpath("./span[1]//text()"))) - if item and item["vod_name"]: - items.append(item) - return items - - def _default_category_pic(self, vod_id): - return f"https://pics.hanju7.com/pics/{vod_id}.jpg" if vod_id else "" - - def _parse_category_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - for node in root.xpath("//div[contains(@class,'list')]//ul/li"): - anchor = node.xpath(".//a[contains(@class,'tu')][1]") - if not anchor: - continue - anchor = anchor[0] - vod_id = self._extract_detail_id((anchor.xpath("./@href") or [""])[0]) - item = self._build_list_item( - anchor, - remarks="".join(node.xpath(".//span[contains(@class,'tip')][1]//text()")), - pic=(anchor.xpath("./@data-original") or [""])[0], - ) - if item: - item["vod_pic"] = item["vod_pic"] or self._default_category_pic(vod_id) - items.append(item) - return items - - def _parse_rank_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - for node in root.xpath("//div[contains(@class,'txt') or contains(@class,'list_txt')]//ul/li"): - anchor = node.xpath(".//a[@href][1]") - if not anchor: - continue - anchor = anchor[0] - item = self._build_list_item(anchor, remarks="".join(node.xpath("./span[1]//text()"))) - if item: - item["vod_pic"] = self._default_category_pic(item["vod_id"]) - items.append(item) - return items - - def homeVideoContent(self): - return {"list": self._parse_home_cards(self._request_html(self.host))[:100]} - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - if str(tid) in ["hot", "new"]: - items = self._parse_rank_cards(self._request_html(f"{self.host}/{tid}.html")) - page_size = 20 - start = (page - 1) * page_size - result = items[start : start + page_size] - return {"page": page, "limit": page_size, "total": len(items), "list": result} - - page_suffix = "" if page <= 1 else str(page - 1) - url = f"{self.host}/list/{tid}---{page_suffix}.html" - items = self._parse_category_cards(self._request_html(url)) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def _extract_redirect_location(self, response): - if response is None: - return "" - return ( - response.headers.get("Location") - or response.headers.get("location") - or response.headers.get("Location".lower()) - or "" - ) - - def _native_post_search(self, keyword): - payload = f"show=searchkey&keyboard={quote(str(keyword or ''))}" - headers = dict(self.headers) - headers["Content-Type"] = "application/x-www-form-urlencoded" - response = self.post( - self.host + "/search/", - data=payload, - headers=headers, - timeout=10, - allow_redirects=False, - ) - cookies = response.headers.get("Set-Cookie") or response.headers.get("set-cookie") or "" - if isinstance(cookies, list): - cookies = "; ".join(cookies) - return self._extract_redirect_location(response), cookies - - def _normalize_search_redirect(self, location): - raw = str(location or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("/"): - return self.host + raw - return self.host + "/search/" + raw.lstrip("/") - - def _parse_search_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - for node in root.xpath("//div[contains(@class,'txt')]//ul/li"): - node_id = (node.xpath("./@id") or [""])[0] - if node_id == "t": - continue - anchor = node.xpath(".//*[@id='name']//a[@href][1]") - if not anchor: - continue - title = self._clean_text("".join(anchor[0].xpath(".//text()"))) - title = re.sub(r"\(\d+\)$", "", title).strip() - items.append( - { - "vod_id": self._extract_detail_id((anchor[0].xpath("./@href") or [""])[0]), - "vod_name": title, - "vod_pic": DEFAULT_PIC, - "vod_remarks": self._clean_text("".join(node.xpath(".//*[@id='actor']//text()"))), - } - ) - return items - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - location, cookie = self._native_post_search(keyword) - url = self._normalize_search_redirect(location) - if not url: - return {"page": page, "total": 0, "list": []} - headers = {"Cookie": cookie} if cookie else None - items = self._parse_search_cards(self._request_html(url, headers=headers)) - return {"page": page, "total": len(items), "list": items} - - def _parse_play_groups(self, html): - root = self.html(html) - if root is None: - return [] - source_name = self._clean_text("".join(root.xpath("//*[@id='playlist'][1]//text()"))) or "新韩剧线路" - episodes = [] - for anchor in root.xpath("//div[contains(@class,'play')]//ul/li//a[@onclick]"): - onclick = (anchor.xpath("./@onclick") or [""])[0] - matched = re.search(r"'([^']+)'", onclick) - if not matched: - continue - name = self._clean_text("".join(anchor.xpath(".//text()"))) or "正片" - episodes.append(f"{name}${matched.group(1)}") - if not episodes: - return [] - return [(source_name, "#".join(episodes))] - - def detailContent(self, ids): - raw = ids[0] if isinstance(ids, list) else ids - vod_id = self._extract_detail_id(raw) - html = self._request_html(f"{self.host}/detail/{vod_id}.html") - root = self.html(html) - if root is None: - return {"list": []} - play_groups = self._parse_play_groups(html) - info = root.xpath("//div[contains(@class,'detail')]//div[contains(@class,'info')]/dl/dd/text()") - info = [self._clean_text(item) for item in info] - pic = (root.xpath("//div[contains(@class,'detail')]//div[contains(@class,'pic')]//img/@data-original") or [""])[0] - vod = { - "vod_id": vod_id, - "vod_name": info[0] if len(info) > 0 else "", - "vod_pic": self._build_url(pic), - "vod_actor": info[1] if len(info) > 1 else "", - "vod_remarks": info[4] if len(info) > 4 else "", - "vod_year": info[5] if len(info) > 5 else "", - "vod_content": self._clean_text("".join(root.xpath("//div[contains(@class,'juqing')][1]//text()"))), - "vod_play_from": "$$$".join(name for name, _ in play_groups), - "vod_play_url": "$$$".join(urls for _, urls in play_groups), - } - return {"list": [vod]} - - def _decrypt_play_url(self, payload): - raw = str(payload or "").strip() - if not raw: - return "" - try: - data = base64.b64decode(raw) - iv = data[:16] - ciphertext = data[16:] - cipher = AES.new(PLAYER_AES_KEY.encode("utf-8"), AES.MODE_CBC, iv) - return unpad(cipher.decrypt(ciphertext), AES.block_size).decode("utf-8").strip() - except Exception: - return "" - - def _is_media_url(self, url): - return bool(re.search(r"\.(m3u8|mp4|flv|avi|mkv|ts)(?:[?#]|$)", str(url or ""), re.I)) - - def playerContent(self, flag, id, vipFlags): - raw_id = str(id or "").strip() - if self._is_media_url(raw_id): - return {"parse": 0, "jx": 0, "url": raw_id, "header": {"Referer": self.host + "/"}} - - encrypted = self._request_text(f"{self.host}/u/u1.php?ud={raw_id}") - real_url = self._decrypt_play_url(encrypted) - if self._is_media_url(real_url): - return {"parse": 0, "jx": 0, "url": real_url, "header": {"Referer": self.host + "/"}} - return {"parse": 1, "jx": 1, "url": real_url or raw_id, "header": {"Referer": self.host + "/"}} diff --git a/py/新韩剧网.txt b/py/新韩剧网.txt new file mode 100644 index 0000000..c640c9a --- /dev/null +++ b/py/新韩剧网.txt @@ -0,0 +1,15 @@ +// ignore +//@name:新韩剧网 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:HHj1feUjyAfKUZhh +//@ek:base64:5iz+1QGH9CCyKIBDFwcldphHI7WTNDeV/2NIxCrEHDn0tlc9uyNxi9gpJurr8UE6 +//@hash:sha256:96e26a21970fb7026c2a27e5bb88786a583b6e3a20cf76f3bff1a28fc154a7a6 +//@sig:base64:l9LX2t+kdjAuTncb9Hp6dlQ9QLAU46dh3Rw+WD9Ug/VVYIpJUO34KDpacOgNJ0HERJbyQHJgtIzfIri9VOdPBQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/星星短剧.py b/py/星星短剧.py deleted file mode 100644 index 8f42ce5..0000000 --- a/py/星星短剧.py +++ /dev/null @@ -1,180 +0,0 @@ -# coding=utf-8 -import json -import sys -from urllib.parse import urlencode - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -HOST = "http://read.api.duodutek.com" -UA = ( - "Mozilla/5.0 (Windows NT 6.1; WOW64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/50.0.2661.87 Safari/537.36" -) -COMMON_PARAMS = { - "productId": "2a8c14d1-72e7-498b-af23-381028eb47c0", - "vestId": "2be070e0-c824-4d0e-a67a-8f688890cadb", - "channel": "oppo19", - "osType": "android", - "version": "20", - "token": "202509271001001446030204698626", -} -CLASS_LIST = [ - {"type_id": "1287", "type_name": "甜宠"}, - {"type_id": "1288", "type_name": "逆袭"}, - {"type_id": "1289", "type_name": "热血"}, - {"type_id": "1290", "type_name": "现代"}, - {"type_id": "1291", "type_name": "古代"}, -] - - -class Spider(BaseSpider): - def __init__(self): - self.name = "星星短剧" - self.host = HOST - self.headers = {"User-Agent": UA} - self.classes = CLASS_LIST - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes, "filters": {}} - - def homeVideoContent(self): - return {"list": self._list_category_items("1287", 1)[:12]} - - def categoryContent(self, tid, pg, filter, extend): - page = max(1, int(pg)) - payload = self._get_json( - self._build_url( - "/novel-api/app/pageModel/getResourceById", - {"resourceId": str(tid), "pageNum": str(page), "pageSize": "10"}, - ) - ) - data = payload.get("data") if isinstance(payload, dict) else {} - items = [self._map_vod(item) for item in (data.get("datalist") or [])] - total = self._coerce_int( - data.get("total") - or data.get("totalCount") - or (data.get("page") or {}).get("totalCount") - or payload.get("total") - ) - return {"page": page, "limit": len(items), "total": total, "list": items} - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - if not vod_id: - continue - book_id, book_name, intro = self._split_vod_id(vod_id) - payload = self._get_json( - self._build_url( - "/novel-api/basedata/book/getChapterList", - {"bookId": book_id}, - ) - ) - chapters = payload.get("data") if isinstance(payload, dict) else [] - episodes = [] - for index, chapter in enumerate(chapters or [], start=1): - play_url = self._extract_play_url(chapter) - if not play_url: - continue - chapter_name = str(chapter.get("chapterName") or f"第{index}集").strip() - episodes.append(f"{chapter_name}${play_url}") - result["list"].append( - { - "vod_id": vod_id, - "vod_name": book_name, - "vod_content": intro, - "vod_remarks": f"共{len(episodes)}集" if episodes else "", - "vod_play_from": "星星短剧", - "vod_play_url": "#".join(episodes), - } - ) - return result - - def searchContent(self, key, quick, pg="1"): - page = max(1, int(pg)) - return {"page": page, "limit": 0, "total": 0, "list": []} - - def playerContent(self, flag, id, vipFlags): - play_url = self._normalize_play_url(id) - if not play_url: - return {"parse": 0, "jx": 0, "url": "", "header": {}} - return { - "parse": 0, - "jx": 0, - "url": play_url, - "header": {"User-Agent": UA}, - } - - def _list_category_items(self, tid, page): - payload = self._get_json( - self._build_url( - "/novel-api/app/pageModel/getResourceById", - {"resourceId": str(tid), "pageNum": str(page), "pageSize": "10"}, - ) - ) - data = payload.get("data") if isinstance(payload, dict) else {} - return [self._map_vod(item) for item in (data.get("datalist") or [])] - - def _map_vod(self, item): - book_id = str(item.get("id") or "").strip() - name = str(item.get("name") or "").strip() - intro = str(item.get("introduction") or "").strip() - heat = str(item.get("heat") or "").strip() - return { - "vod_id": f"{book_id}@@{name}@@{intro}", - "vod_name": name, - "vod_pic": str(item.get("icon") or "").strip(), - "vod_remarks": f"{heat}万播放" if heat else "", - } - - def _split_vod_id(self, vod_id): - parts = vod_id.split("@@", 2) - if len(parts) == 3: - return parts[0], parts[1], parts[2] - if len(parts) == 2: - return parts[0], parts[1], "" - return vod_id, "", "" - - def _extract_play_url(self, chapter): - for play_group in chapter.get("shortPlayList") or []: - for play in play_group.get("chapterShortPlayVoList") or []: - play_url = self._normalize_play_url(play.get("shortPlayUrl")) - if play_url: - return play_url - return "" - - def _normalize_play_url(self, value): - play_url = str(value or "").strip() - if play_url.startswith("http://img.novel.wsljf.xyz/"): - return "https://" + play_url[len("http://"):] - return play_url - - def _build_url(self, path, params=None): - query = urlencode({**COMMON_PARAMS, **(params or {})}) - return f"{self.host}{path}?{query}" - - def _coerce_int(self, value): - try: - return int(value) - except (TypeError, ValueError): - return 0 - - def _get_json(self, url): - response = self.fetch(url, headers=dict(self.headers), timeout=10, verify=False) - if response.status_code != 200: - return {} - try: - return json.loads(response.text or "{}") - except (json.JSONDecodeError, TypeError, ValueError): - return {} diff --git a/py/星星短剧.txt b/py/星星短剧.txt new file mode 100644 index 0000000..8dd13b1 --- /dev/null +++ b/py/星星短剧.txt @@ -0,0 +1,15 @@ +// ignore +//@name:星星短剧 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:TgA5yZhPbQCIXyQL +//@ek:base64:8SG67WroJyIIXAjmANvA+iUzKRm9Rv7jpbMCIVyr8WinjvOFf2ImZrxzed2EHHlH +//@hash:sha256:ccc46ee2cdd8ed718d50ba979fe82a08e0fde3d073c300f0cb5af08015b6a0be +//@sig:base64:GYtBD61sAh+uK7XDrhD39bPzbFcYmRxv81AVjY+CqoHtUxyo2g/jSSqnetvvgFymeZERc2gVf/WwpYn3cIxTAw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/木偶.py b/py/木偶.py deleted file mode 100644 index 0511972..0000000 --- a/py/木偶.py +++ /dev/null @@ -1,277 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin, urlsplit - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "木偶" - self.hosts = ["https://www.muou.site", "https://www.muou.asia", "https://666.666291.xyz"] - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.hosts[0] + "/", - } - self.categories = [ - {"type_id": "25", "type_name": "木偶臻选"}, - {"type_id": "1", "type_name": "木偶电影"}, - {"type_id": "2", "type_name": "木偶电视剧"}, - {"type_id": "3", "type_name": "木偶动漫"}, - {"type_id": "4", "type_name": "木偶纪录片"}, - {"type_id": "29", "type_name": "木偶综艺"}, - {"type_id": "30", "type_name": "木偶原盘"}, - ] - self.pan_patterns = [ - ("baidu", "百度资源", r"pan\.baidu\.com|yun\.baidu\.com"), - ("a139", "139资源", r"yun\.139\.com"), - ("a189", "天翼资源", r"cloud\.189\.cn"), - ("a123", "123资源", r"123684\.com|123865\.com|123912\.com|123pan\.com"), - ("a115", "115资源", r"115\.com|115cdn\.com"), - ("quark", "夸克资源", r"pan\.quark\.cn|quark\.cn"), - ("xunlei", "迅雷资源", r"pan\.xunlei\.com|xunlei\.com"), - ("aliyun", "阿里资源", r"aliyundrive\.com|alipan\.com"), - ("uc", "UC资源", r"drive\.uc\.cn|uc\.cn"), - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.hosts[0] + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _detect_pan_type(self, url): - raw = str(url or "").strip() - for pan_type, title, pattern in self.pan_patterns: - if re.search(pattern, raw, re.I): - return pan_type, title - return "", "" - - def _request_html(self, path_or_url): - raw = str(path_or_url or "").strip() - relative = raw - if raw.startswith("http"): - parsed = urlsplit(raw) - relative = parsed.path or "/" - if parsed.query: - relative += "?" + parsed.query - - last_error = None - for index, host in enumerate(list(self.hosts)): - target = raw if raw.startswith("http") and raw.startswith(host) else urljoin(host + "/", relative) - try: - headers = dict(self.headers) - headers["Referer"] = host + "/" - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code == 200 and response.text: - if index > 0: - self.hosts.insert(0, self.hosts.pop(index)) - self.headers["Referer"] = self.hosts[0] + "/" - return response.text or "" - except Exception as exc: - last_error = exc - if last_error: - raise last_error - return "" - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for node in root.xpath( - "//*[@id='main']//*[contains(concat(' ', normalize-space(@class), ' '), ' module-item ')]" - ): - href = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//a[@href])[1]/@href") or [""])[0]).strip() - title = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@alt])[1]/@alt") or [""])[0]).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-text')])[1]//text()"))) - year = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-caption')])[1]//span[1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - "vod_year": year, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_url(f"/index.php/vod/type/id/{tid}/page/{int(pg)}.html") - return self._page_result(self._parse_cards(self._request_html(url)), pg) - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - page = int(pg) - if not keyword: - return {"page": page, "total": 0, "list": []} - - url = self._build_url(f"/vodsearch/-------------.html?wd={quote(keyword)}&page={page}") - root = self.html(self._request_html(url)) - if root is None: - return {"page": page, "total": 0, "list": []} - - items = [] - for node in root.xpath("//*[contains(@class,'module-search-item')]"): - href = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@href")).strip() - title = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@title")).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'video-serial')][1]//text()")) - or "".join(node.xpath(".//*[contains(@class,'module-item-text')][1]//text()")) - ) - if not href or not title: - continue - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return {"page": page, "total": len(items), "list": items} - - def _parse_detail_page(self, vod_id, html): - root = self.html(html) - if root is None: - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - detail = { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath("//*[contains(@class,'page-title')][1]//text()"))), - "vod_pic": self._build_url( - ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@data-src") or [""])[0] - ).strip() - or ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@src") or [""])[0] - ).strip() - ), - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - for label_node in root.xpath("//*[contains(@class,'video-info-itemtitle')]"): - key = self._clean_text("".join(label_node.xpath(".//text()"))) - sibling = label_node.getnext() - if sibling is None: - continue - values = [self._clean_text(text) for text in sibling.xpath(".//a//text()")] - joined = ",".join([value for value in values if value]) - text_value = self._clean_text("".join(sibling.xpath(".//text()"))) - if "年代" in key: - detail["vod_year"] = joined or text_value - elif "导演" in key: - detail["vod_director"] = joined or text_value - elif "主演" in key: - detail["vod_actor"] = joined or text_value - elif "剧情" in key: - detail["vod_content"] = text_value - - for node in root.xpath("//*[contains(@class,'module-row-info')]//p"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if text: - detail["pan_urls"].append(text) - return detail - - def _build_pan_lines(self, detail): - lines = [] - seen = set() - for url in detail.get("pan_urls", []): - pan_type, title = self._detect_pan_type(url) - if not pan_type or url in seen: - continue - seen.add(url) - lines.append((self.pan_priority.get(pan_type, 999), f"{pan_type}#木偶", f"{title}${url}")) - lines.sort(key=lambda item: item[0]) - return [(item[1], item[2]) for item in lines] - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail = self._parse_detail_page(vod_id, self._request_html(self._build_url(vod_id))) - lines = self._build_pan_lines(detail) - result["list"].append( - { - "vod_id": vod_id, - "vod_name": detail["vod_name"], - "vod_pic": detail["vod_pic"], - "vod_year": detail["vod_year"], - "vod_director": detail["vod_director"], - "vod_actor": detail["vod_actor"], - "vod_content": detail["vod_content"], - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - pan_type, _ = self._detect_pan_type(id) - if pan_type: - return {"parse": 0, "playUrl": "", "url": id} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/木偶.txt b/py/木偶.txt new file mode 100644 index 0000000..e761aed --- /dev/null +++ b/py/木偶.txt @@ -0,0 +1,15 @@ +// ignore +//@name:木偶 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:N2Y5OdEidE9nyon1 +//@ek:base64:xf78Zkwv/pz0Cn9mjoblHU02nXxs9Umi0CEThR3B3QMRJPi/S1M5ZmHx1wYfR9nO +//@hash:sha256:4a2f87a86c3e07d6f23f71759f1f5f7f91198fa50c4242d367a8af82c1fd84c9 +//@sig:base64:9uZpj0mET+2ZFoWMirQRDD/iQOOw8+31sg/bmhWLzRFFiHChDzUYJpia/XgLQLwMlUk0YKPj6ERj0kVJSZ1SBQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/樱花动漫.py b/py/樱花动漫.py deleted file mode 100644 index 4a1f1bc..0000000 --- a/py/樱花动漫.py +++ /dev/null @@ -1,283 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "樱花动漫" - self.host = "https://www.dmvvv.com" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " - "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" - ), - "Referer": "https://www.dmvvv.com/", - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - } - self.classes = [ - {"type_id": "guoman", "type_name": "国产动漫"}, - {"type_id": "riman", "type_name": "日本动漫"}, - {"type_id": "oman", "type_name": "欧美动漫"}, - {"type_id": "dmfilm", "type_name": "动漫电影"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - html = self._get_html(self.host + "/") - items = self._parse_list(html) - seen = set() - unique = [] - for item in items: - if item["vod_id"] not in seen: - seen.add(item["vod_id"]) - unique.append(item) - return {"list": unique[:20]} - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - url = f"{self.host}/type/{tid}/" if page <= 1 else f"{self.host}/type/{tid}/{page}/" - html = self._get_html(url) - items = self._parse_list(html) - pagecount = self._parse_page_count(html, tid) - if pagecount <= page and len(items) >= 36: - pagecount = page + 1 - return { - "list": items, - "page": page, - "pagecount": pagecount, - "total": pagecount * len(items) if items else 0, - } - - def detailContent(self, ids): - raw_id = ids[0] if isinstance(ids, list) else ids - url = raw_id if raw_id.startswith("http") else self.host + raw_id - html = self._get_html(url) - vod = self._parse_detail(html, raw_id) - return {"list": [vod] if vod else []} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = key.strip() - if not keyword: - return {"list": [], "page": page, "pagecount": 0, "total": 0} - encoded = quote(keyword) - url = ( - f"{self.host}/search/?wd={encoded}" - if page <= 1 - else f"{self.host}/search/?wd={encoded}&pageno={page}" - ) - html = self._get_html(url) - items = self._parse_search_list(html) - pagecount = self._parse_search_page_count(html, page, len(items)) - return { - "list": items[:10] if quick else items, - "page": page, - "pagecount": pagecount, - "total": len(items), - } - - def playerContent(self, flag, id, vipFlags): - url = id if id.startswith("http") else self.host + id - html = self._get_html(url) - play_url = self._extract_play_url(html, url) - return { - "parse": 0, - "url": play_url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": self.host + "/", - }, - } - - # --- helpers --- - - def _s(self, val): - return "" if val is None else str(val).strip() - - def _get_html(self, url): - rsp = self.fetch(url, headers=self.headers, timeout=15, verify=False) - if rsp.status_code != 200: - return "" - return rsp.text or "" - - def _parse_list(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - for li in root.xpath("//li"): - link = li.xpath(".//a[@href]") - if not link: - continue - href = self._s(link[0].get("href", "")) - title = self._s(link[0].get("title", "")) - if not href or "/detail/" not in href or not title: - continue - pic = self._s((li.xpath(".//img/@data-original") or li.xpath(".//img/@src") or [""])[0]) - remarks = self._s((li.xpath(".//p//text()") or [""])[0]) - items.append({ - "vod_id": href, - "vod_name": title, - "vod_pic": pic, - "vod_remarks": remarks, - }) - return items - - def _parse_search_list(self, html): - items = [] - pattern = re.compile(r'\s*", html, re.S): - chunk = block.group(0) - href_m = pattern.search(chunk) - if not href_m: - continue - title_m = re.search(r'title="([^"]+)"', chunk) - cover_m = re.search(r'data-original="([^"]+)"', chunk) - remark_m = re.search(r'
状态:([^<]*)', chunk) - if not title_m: - continue - items.append({ - "vod_id": href_m.group(1), - "vod_name": title_m.group(1).strip(), - "vod_pic": cover_m.group(1).strip() if cover_m else "", - "vod_remarks": remark_m.group(1).strip() if remark_m else "", - }) - return items - - def _parse_page_count(self, html, tid): - max_page = 1 - for m in re.finditer(r"/type/[^/]+/(\d+)/", html): - max_page = max(max_page, int(m.group(1))) - for m in re.finditer(r"[?&]page(?:no)?=(\d+)", html): - max_page = max(max_page, int(m.group(1))) - return max_page - - def _parse_search_page_count(self, html, current_page, result_count): - total_m = re.search(r"找到\s*(\d+)", html) - if total_m: - return max(1, -(-int(total_m.group(1)) // 12)) - max_page = current_page - for m in re.finditer(r"pageno=(\d+)", html): - max_page = max(max_page, int(m.group(1))) - if max_page == current_page and result_count >= 12: - return current_page + 1 - return max(max_page, 1) - - def _parse_detail(self, html, raw_id): - root = self.html(html) - if root is None: - return None - title = "" - title_m = re.search(r'
.*?

([^<]+)

', html, re.S) - if title_m: - title = title_m.group(1).strip() - if not title: - title_m2 = re.search(r"([^<]+)", html) - if title_m2: - title = title_m2.group(1).split("-")[0].strip() - - cover = "" - cover_m = re.search(r'<div class="cover">\s*<img[^>]+data-original="([^"]+)"', html, re.S) - if cover_m: - cover = cover_m.group(1) - - def get_info(label, use_em=True): - pat = rf'<span>{label}:</span><em>([^<]+)</em>' if use_em else rf'<span>{label}:</span>([^<]+)' - m = re.search(pat, html) - return m.group(1).strip() if m else "" - - vod_remarks = get_info("状态", True) - vod_year = get_info("年份", False) - vod_area = get_info("地区", False) - vod_type = get_info("类型", False) - vod_actor = get_info("主演", False) - - vod_content = "" - desc_m = re.search(r'class="blurb"[^>]*>.*?<span>[^<]+</span>(.*?)</li>', html, re.S) - if desc_m: - vod_content = re.sub(r"<[^>]+>", "", desc_m.group(1)).strip() - - play_data = self._parse_play_sources(html, raw_id) - - return { - "vod_id": raw_id, - "vod_name": title, - "vod_pic": cover, - "vod_year": vod_year, - "vod_area": vod_area, - "vod_type": vod_type, - "vod_actor": vod_actor, - "vod_remarks": vod_remarks, - "vod_content": vod_content, - "vod_play_from": play_data["vod_play_from"], - "vod_play_url": play_data["vod_play_url"], - } - - def _parse_play_sources(self, html, raw_id): - root = self.html(html) - if root is None: - return {"vod_play_from": "default", "vod_play_url": ""} - source_names = ["高清", "ikun", "非凡", "量子"] - # collect tab names in order - tabs = [] - for idx, tab in enumerate(root.xpath("//*[contains(@class,'module-tab-item') or contains(@class,'tab-item')]")): - name = self._s(tab.xpath("string(.)")).strip() - if not name: - name = source_names[idx] if idx < len(source_names) else f"线路{idx+1}" - tabs.append(name) - # group episodes by source index from URL: /play/{vid}-{sourceIdx}-{epIdx}/ - grouped = {} - all_links = root.xpath("//*[contains(@class,'module-play-list')]//a[@href] | //*[contains(@class,'playlist')]//a[@href]") - # fallback: try all links under .scroll-content or .module-list - if not all_links: - all_links = root.xpath("//*[contains(@class,'scroll-content') or contains(@class,'module-list')]//a[@href]") - for a in all_links: - ep_name = self._s(a.xpath("string(.)")).strip() - ep_url = self._s(a.get("href", "")) - if not ep_name or not ep_url or ep_url.startswith(("javascript:", "#")): - continue - m = re.search(r"/play/\d+-(\d+)-\d+/", ep_url) - if m: - src_idx = int(m.group(1)) - 1 - else: - src_idx = 0 - if src_idx not in grouped: - grouped[src_idx] = [] - grouped[src_idx].append(f"{ep_name}${ep_url}") - if not grouped: - return {"vod_play_from": "default", "vod_play_url": ""} - # build output ordered by source index - play_from = [] - play_url = [] - for src_idx in sorted(grouped.keys()): - name = tabs[src_idx] if src_idx < len(tabs) else (source_names[src_idx] if src_idx < len(source_names) else f"线路{src_idx+1}") - play_from.append(name) - play_url.append("#".join(grouped[src_idx])) - return { - "vod_play_from": "$$$".join(play_from), - "vod_play_url": "$$$".join(play_url), - } - - def _extract_play_url(self, html, fallback_url): - m = re.search(r"url:\s*'(https?://[^']+)'", html) - if m: - return m.group(1) - m = re.search(r"(https?://[^\s'\"<>]+\.m3u8(?:\?[^\s'\"<>]*)?)", html) - if m: - return m.group(1) - return fallback_url diff --git a/py/樱花动漫.txt b/py/樱花动漫.txt new file mode 100644 index 0000000..7efc06e --- /dev/null +++ b/py/樱花动漫.txt @@ -0,0 +1,15 @@ +// ignore +//@name:樱花动漫 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:ZQH626xNktKH8AuE +//@ek:base64:vB/TxrsRFE4ZxB3O9O3NEhz89dDhJhAoyNt9j9sxTW8cFwwUL8tb6LiBYnQO4UBc +//@hash:sha256:914defca1898ac508147cf3870d624f49d0f265ceb7fc8dfbeccb0e9c260af10 +//@sig:base64:+vD0gzK8CdIGquzUqnkkkFrUa/4XVXjqWW7xkVvY6VmoENqaKEnYR302ySyKIPK1wJ1c06HO+r5iGkscNXYcDQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/橘子TV.py b/py/橘子TV.py deleted file mode 100644 index 53d6666..0000000 --- a/py/橘子TV.py +++ /dev/null @@ -1,303 +0,0 @@ -# coding=utf-8 -import hashlib -import json -import sys -import uuid - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "橘子TV" - self.config_url = "https://gapi0725.5p8jcjc.com/config.json" - self.api_host = "" - self.headers = { - "User-Agent": "Dart/3.1 (dart:io)", - "Accept-Encoding": "gzip", - "content-type": "application/json; charset=utf-8", - } - self.app_id = "fea23e11fc1241409682880e15fb2851" - self.app_key = "f384b87cc9ef41e4842dda977bae2c7f" - self.udid = "bfc18c00-c866-46cb-8d7b-121c39b942d4" - self.bundler_id = "com.voraguzzee.ts" - self.source = "1003_default" - self.version = "1.0.1" - self.version_code = 1000 - self.inited = False - self.next = ["", ""] - - def init(self, extend=""): - if self.inited: - return None - - response = self.fetch(self.config_url, headers=self.headers, timeout=10, verify=False) - raw = response.text or "" - - try: - hosts = json.loads(raw) - except Exception: - hosts = [item.strip() for item in raw.replace("\n", ",").split(",") if item.strip()] - - for host in hosts: - if str(host).startswith("http"): - self.api_host = str(host).rstrip("/") - break - - if not self.api_host: - raise ValueError("未能获取到有效的API地址") - - self.inited = True - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def _dict_to_query(self, data): - parts = [] - for key, value in data.items(): - if value != "": - parts.append(f"{key}={value}") - return "&".join(parts) - - def _sign_data(self, data): - sorted_data = {key: data[key] for key in sorted(data)} - query = self._dict_to_query(sorted_data) - sign_source = f"{query}&appKey={self.app_key}" if query else f"appKey={self.app_key}" - signed = dict(data) - signed["sign"] = hashlib.md5(sign_source.encode("utf-8")).hexdigest() - return signed - - def _build_payload(self, extra=None): - payload = { - "appId": self.app_id, - "bundlerId": self.bundler_id, - "cus1tom": "cus3tom", - "deviceInfo": "xiaomi", - "osInfo": "15", - "otherParam": "1", - "patchNumber": 0, - "requestId": str(uuid.uuid4()), - "source": self.source, - "udid": self.udid, - "version": self.version, - "versionCode": self.version_code, - } - if extra: - payload.update(extra) - return self._sign_data(payload) - - def _post_api(self, path, payload): - response = self.post( - f"{self.api_host}{path}", - json=payload, - headers=self.headers, - timeout=15, - verify=False, - ) - if response.status_code != 200: - return {} - try: - return json.loads(response.text or "{}") - except Exception: - return {} - - def _parse_year(self, flags): - text = str(flags or "") - if not text: - return "" - return text.split(" / ")[0].strip() - - def homeContent(self, filter): - response = self._post_api("/v2/api/home/header", self._build_payload()) - classes = [] - for item in response.get("data", {}).get("channeList", []): - if item.get("channelId"): - classes.append( - { - "type_id": str(item.get("channelId")), - "type_name": item.get("channelName", ""), - } - ) - return {"class": classes} - - def homeVideoContent(self): - response = self._post_api("/v2/api/home/body", self._build_payload()) - videos = [] - for topic in response.get("data", {}).get("vodTopicList", []): - for item in topic.get("vodList", []): - videos.append( - { - "vod_id": str(item.get("vodId", "")), - "vod_name": item.get("vodName", ""), - "vod_pic": item.get("coverImg", ""), - "vod_remarks": item.get("remark") or f"评分：{item.get('score', '')}", - "vod_year": self._parse_year(item.get("flags")), - } - ) - return {"list": videos} - - def _map_video_item(self, item): - return { - "vod_id": str(item.get("vodId", "")), - "vod_name": item.get("vodName", ""), - "vod_pic": item.get("coverImg", ""), - "vod_remarks": item.get("remark") or f"评分：{item.get('score', '')}", - "vod_year": self._parse_year(item.get("flags")), - "vod_content": item.get("intro", ""), - } - - def _page_result(self, items, pg, has_next): - page = int(pg) - return { - "list": items, - "page": page, - "limit": len(items), - "total": page * 30 + len(items), - } - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - payload = self._build_payload( - { - "nextCount": 18, - "nextVal": self.next[page] if page < len(self.next) else "", - "queryValueJson": json.dumps( - [{"filerName": "channelId", "filerValue": str(tid)}], - ensure_ascii=False, - separators=(",", ":"), - ), - "sortType": "", - } - ) - response = self._post_api("/v1/api/search/queryNow", payload) - data = response.get("data", {}) - nextVal = data.get("nextVal", '') - while len(self.next) <= page + 1: - self.next.append("") - self.next[page + 1] = nextVal - items = [self._map_video_item(item) for item in data.get("items", []) if isinstance(item, dict)] - return self._page_result(items, pg, data.get("hasNext") == 1) - - def searchContent(self, key, quick, pg="1"): - payload = self._build_payload({"keyword": key, "nextVal": ""}) - response = self._post_api("/v1/api/search/search", payload) - data = response.get("data", {}) - items = [self._map_video_item(item) for item in data.get("items", []) if isinstance(item, dict)] - return self._page_result(items, pg, data.get("hasNext") == 1) - - def _parse_people(self, people): - names = [] - for item in people or []: - if isinstance(item, dict) and item.get("vodWorkerName"): - names.append(item.get("vodWorkerName")) - return ",".join(names) - - def _quality_score(self, show_name, resolution): - text = "{0} {1}".format(str(show_name or "").lower(), str(resolution or "").lower()) - digits = "".join(ch for ch in text if ch.isdigit()) - if digits: - try: - return int(digits) - except Exception: - pass - - named_scores = { - "原画": 5000, - "蓝光": 4500, - "4k": 4000, - "2160": 4000, - "超清": 3000, - "uhd": 3000, - "1080": 2800, - "fhd": 2800, - "高清": 2000, - "hd": 2000, - "720": 1800, - "标清": 1000, - "sd": 1000, - "流畅": 500, - "ld": 500, - } - for key, score in named_scores.items(): - if key in text: - return score - return 0 - - def detailContent(self, ids): - vod_id = ids[0] - response = self._post_api("/v2/api/vodInfo/index", self._build_payload({"vodId": vod_id})) - data = response.get("data", {}) - - play_from = [] - play_urls = [] - for player in data.get("playerList", []): - play_from.append(player.get("playerName", "")) - episodes = [] - for episode in player.get("epList", []): - episodes.append(f"{episode.get('epName', '')}${episode.get('epId', '')}") - play_urls.append("#".join(episodes)) - - return { - "list": [ - { - "vod_id": str(data.get("vodId", "")), - "vod_name": data.get("vodName", ""), - "vod_pic": data.get("coverImg", ""), - "vod_remarks": data.get("updateRemark", ""), - "vod_year": data.get("year", ""), - "vod_area": data.get("areaName", ""), - "vod_actor": self._parse_people(data.get("actorList")), - "vod_director": self._parse_people(data.get("directorList")), - "vod_content": data.get("intro", ""), - "vod_play_from": "$$$".join(play_from), - "vod_play_url": "$$$".join(play_urls), - } - ] - } - - def playerContent(self, flag, id, vipFlags): - response = self._post_api("/v2/api/vodInfo/epDetail", self._build_payload({"vodEpId": id})) - candidates = [] - - for item in response.get("data", []): - show_name = item.get("showName") - resolution = item.get("vodResolution") - if not show_name or not resolution: - continue - - play_response = self._post_api( - "/v2/api/vodInfo/playUrl", - self._build_payload({"epId": id, "vodResolution": resolution}), - ) - play_url = play_response.get("data", {}).get("playUrl", "") - if str(play_url).startswith("http"): - candidates.append( - { - "showName": show_name, - "vodResolution": resolution, - "playUrl": play_url, - "score": self._quality_score(show_name, resolution), - } - ) - - if not candidates: - return {"parse": 0, "playUrl": "", "url": ""} - - best = sorted(candidates, key=lambda item: item["score"], reverse=True)[0] - - return { - "parse": 0, - "playUrl": "", - "url": best["playUrl"], - "header": { - "User-Agent": "ExoPlayer", - "Connection": "Keep-Alive", - "Accept-Encoding": "gzip", - }, - } diff --git a/py/橘子TV.txt b/py/橘子TV.txt new file mode 100644 index 0000000..7fae5e3 --- /dev/null +++ b/py/橘子TV.txt @@ -0,0 +1,15 @@ +// ignore +//@name:橘子TV +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:KAdFcc9yAkA12PA9 +//@ek:base64:k3Ij0Y/Dt+5vwo/DgLG0tEIuocGc/arbrmePOrJ5bRxnlCGmHBx/CjdcweW6Dpg8 +//@hash:sha256:eace773568e776861d6997b7ea40f886cd2b0bb057a1324a16123d40272e5ece +//@sig:base64:oeDOkf1fSkB+Fw68jynBVjYsWgfXl4WiMPb/wZUPH4POyYosxJBelPhqN21DDkfQAvoHz8CRhxOrwW9pES5nBA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/欧歌.py b/py/欧歌.py deleted file mode 100644 index df075ed..0000000 --- a/py/欧歌.py +++ /dev/null @@ -1,278 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote -from urllib.parse import urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "欧歌" - self.host = "https://woog.nxog.eu.org" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "1", "type_name": "欧歌电影"}, - {"type_id": "2", "type_name": "欧哥剧集"}, - {"type_id": "3", "type_name": "欧歌动漫"}, - {"type_id": "4", "type_name": "欧歌综艺"}, - {"type_id": "5", "type_name": "欧歌短剧"}, - {"type_id": "21", "type_name": "欧歌综合"}, - ] - self.pan_patterns = [ - ("baidu", "百度资源", r"pan\.baidu\.com|yun\.baidu\.com"), - ("a139", "139资源", r"yun\.139\.com"), - ("a189", "天翼资源", r"cloud\.189\.cn"), - ("a123", "123资源", r"123pan\.com|123684\.com|123865\.com|123912\.com"), - ("a115", "115资源", r"115\.com"), - ("quark", "夸克资源", r"pan\.quark\.cn"), - ("xunlei", "迅雷资源", r"pan\.xunlei\.com"), - ("aliyun", "阿里资源", r"aliyundrive\.com|alipan\.com"), - ("uc", "UC资源", r"drive\.uc\.cn"), - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - return {"list": []} - - def _stringify(self, value): - return "" if value is None else str(value) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", self._stringify(text).replace("\xa0", " ")).strip() - - def _build_url(self, path): - raw = self._stringify(path).strip() - if not raw: - return "" - return urljoin(self.host + "/", raw) - - def _request_html(self, path_or_url, headers=None, referer=None): - target = path_or_url if self._stringify(path_or_url).startswith("http") else self._build_url(path_or_url) - merged_headers = dict(self.headers) - if headers: - merged_headers.update(headers) - merged_headers["Referer"] = referer or self.headers["Referer"] - response = self.fetch(target, headers=merged_headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _detect_pan_type(self, url): - raw = self._stringify(url).strip() - for pan_type, title, pattern in self.pan_patterns: - if re.search(pattern, raw, re.I): - return pan_type, title - return "", "" - - def _fix_img_url(self, img_url): - raw = self._stringify(img_url).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - return self._build_url(raw) - - def _build_category_url(self, tid, pg): - return self._build_url(f"/index.php/vod/show/id/{self._stringify(tid).strip()}/page/{int(pg)}.html") - - def _build_search_url(self, key, pg): - return self._build_url(f"/index.php/vod/search/page/{int(pg)}/wd/{quote(self._stringify(key).strip())}.html") - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for card in root.xpath("//*[@id='main']//*[contains(@class,'module-item')]"): - href = ((card.xpath(".//*[contains(@class,'module-item-pic')]//a[@href][1]/@href") or [""])[0]).strip() - title = ((card.xpath(".//*[contains(@class,'module-item-pic')]//img[@alt][1]/@alt") or [""])[0]).strip() - pic = ( - ((card.xpath(".//*[contains(@class,'module-item-pic')]//img[@data-src][1]/@data-src") or [""])[0]).strip() - or ((card.xpath(".//*[contains(@class,'module-item-pic')]//img[@src][1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(card.xpath(".//*[contains(@class,'module-item-text')][1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._fix_img_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def _parse_search_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for card in root.xpath("//*[contains(@class,'module-search-item')]"): - href = ((card.xpath(".//*[contains(@class,'video-serial')][1]/@href") or [""])[0]).strip() - title = ( - ((card.xpath(".//*[contains(@class,'video-serial')][1]/@title") or [""])[0]).strip() - or ((card.xpath(".//*[contains(@class,'module-item-pic')]//img[@alt][1]/@alt") or [""])[0]).strip() - ) - pic = ( - ((card.xpath(".//*[contains(@class,'module-item-pic')]//img[@data-src][1]/@data-src") or [""])[0]).strip() - or ((card.xpath(".//*[contains(@class,'module-item-pic')]//img[@src][1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(card.xpath(".//*[contains(@class,'video-serial')][1]//text()"))) - if not remarks: - remarks = self._clean_text("".join(card.xpath(".//*[contains(@class,'module-item-text')][1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._fix_img_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - items = self._parse_cards(self._request_html(self._build_category_url(tid, pg))) - return {"list": items, "page": page, "limit": len(items), "total": page * 20 + len(items)} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._stringify(key).strip() - if not keyword: - return {"page": page, "total": 0, "list": []} - items = self._parse_search_cards(self._request_html(self._build_search_url(keyword, pg))) - return {"page": page, "total": len(items), "list": items} - - def _blank_detail(self, vod_id): - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "vod_play_from": "", - "vod_play_url": "", - } - - def _extract_share_url(self, text): - matched = re.search(r"https?://[^\s'\"<>]+", self._stringify(text), re.I) - return matched.group(0).strip() if matched else "" - - def _join_people(self, node): - values = [self._clean_text(text) for text in node.xpath(".//a//text()")] - if not any(values): - values = [self._clean_text(text) for text in node.xpath(".//text()")] - values = [value for value in values if value] - return ",".join(values) - - def _extract_pan_groups(self, root): - groups = [] - seen = set() - for node in root.xpath("//*[contains(@class,'module-row-info')]//p"): - text = self._clean_text("".join(node.xpath(".//text()"))) - share_url = self._extract_share_url(text) - pan_type, title = self._detect_pan_type(share_url) - if not share_url or not pan_type or share_url in seen: - continue - seen.add(share_url) - groups.append((pan_type, f"{title}${share_url}")) - groups.sort(key=lambda item: self.pan_priority.get(item[0], 999)) - return groups - - def _parse_detail_page(self, html, vod_id): - if not self._stringify(html).strip(): - return self._blank_detail(vod_id) - root = self.html(html) - if root is None: - return self._blank_detail(vod_id) - - vod = self._blank_detail(vod_id) - vod["vod_name"] = self._clean_text("".join(root.xpath("(//*[contains(@class,'page-title')])[1]//text()"))) - pic = ( - ((root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@data-src") or [""])[0]).strip() - or ((root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@src") or [""])[0]).strip() - ) - vod["vod_pic"] = self._fix_img_url(pic) - vod["vod_year"] = self._clean_text( - ((root.xpath("(//*[contains(@class,'module-item-caption')]//span[1]/text())") or [""])[0]) - ) - - for label_node in root.xpath("//*[contains(@class,'video-info-itemtitle')]"): - label = self._clean_text("".join(label_node.xpath(".//text()"))) - siblings = label_node.xpath("./following-sibling::*[1]") - if not siblings: - continue - block = siblings[0] - if "导演" in label: - vod["vod_director"] = self._join_people(block) - elif "主演" in label: - vod["vod_actor"] = self._join_people(block) - elif "剧情" in label: - texts = block.xpath(".//p//text()") or block.xpath(".//text()") - vod["vod_content"] = self._clean_text("".join(texts)) - - pan_groups = self._extract_pan_groups(root) - vod["vod_play_from"] = "$$$".join(item[0] for item in pan_groups) - vod["vod_play_url"] = "$$$".join(item[1] for item in pan_groups) - return vod - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = self._stringify(raw_id).strip() - if not vod_id: - continue - html = self._request_html(self._build_url(vod_id)) - result["list"].append(self._parse_detail_page(html, vod_id)) - return result - - def _is_supported_pan_link(self, url): - return bool(self._detect_pan_type(url)[0]) - - def playerContent(self, flag, id, vipFlags): - target = self._stringify(id).strip() - if target and self._is_supported_pan_link(target): - return {"parse": 0, "jx": 0, "playUrl": "", "url": target, "header": {}} - return {"parse": 0, "jx": 0, "playUrl": "", "url": "", "header": {}} diff --git a/py/欧歌.txt b/py/欧歌.txt new file mode 100644 index 0000000..8272cb2 --- /dev/null +++ b/py/欧歌.txt @@ -0,0 +1,15 @@ +// ignore +//@name:欧歌 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:1pXmsItWJkPdNnuB +//@ek:base64:LBnQMXjZOvuBszLLlVd9I4p+CSpdIz2FPBGIKODz6EwFTJGmcYVZqoY+lSk4HbhY +//@hash:sha256:cff0782f0ba411e9d25dbe5a65790aa9a9971fd3bd345f5dd2b336b871115305 +//@sig:base64:OMEiHe1+j9oJ81A552D1DdOht355jk+UDgSFYuOcR5mpog3Q51DGhndn4cgdX5ehL42DBBExP5YFi82u923XDQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/滴答影视.py b/py/滴答影视.py deleted file mode 100644 index 1b476d5..0000000 --- a/py/滴答影视.py +++ /dev/null @@ -1,324 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -from urllib.parse import quote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "滴答影视" - self.host = "https://www.didahd.pro" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/120.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "电视剧"}, - {"type_id": "5", "type_name": "综艺"}, - {"type_id": "4", "type_name": "动漫"}, - {"type_id": "3", "type_name": "纪录片"}, - ] - self.filter_def = { - "1": {"cateId": "1", "area": "", "sort": "time", "class": "", "lang": "", "letter": "", "year": ""}, - "2": {"cateId": "2", "area": "", "sort": "time", "class": "", "lang": "", "letter": "", "year": ""}, - "3": {"cateId": "3", "area": "", "sort": "time", "class": "", "lang": "", "letter": "", "year": ""}, - "4": {"cateId": "4", "area": "", "sort": "time", "class": "", "lang": "", "letter": "", "year": ""}, - "5": {"cateId": "5", "area": "", "sort": "time", "class": "", "lang": "", "letter": "", "year": ""}, - } - self.filters = json.loads( - """ - { - "1": [ - {"key":"class","name":"按剧情","init":"","value":[{"n":"全部","v":""},{"n":"喜剧","v":"喜剧"},{"n":"爱情","v":"爱情"},{"n":"恐怖","v":"恐怖"},{"n":"动作","v":"动作"},{"n":"科幻","v":"科幻"},{"n":"剧情","v":"剧情"},{"n":"战争","v":"战争"},{"n":"警匪","v":"警匪"},{"n":"犯罪","v":"犯罪"},{"n":"动画","v":"动画"},{"n":"奇幻","v":"奇幻"},{"n":"武侠","v":"武侠"},{"n":"冒险","v":"冒险"},{"n":"枪战","v":"枪战"},{"n":"悬疑","v":"悬疑"},{"n":"惊悚","v":"惊悚"},{"n":"经典","v":"经典"},{"n":"青春","v":"青春"},{"n":"文艺","v":"文艺"},{"n":"微电影","v":"微电影"},{"n":"古装","v":"古装"},{"n":"历史","v":"历史"},{"n":"运动","v":"运动"},{"n":"农村","v":"农村"},{"n":"儿童","v":"儿童"},{"n":"网络电影","v":"网络电影"}]}, - {"key":"area","name":"按地区","init":"","value":[{"n":"全部","v":""},{"n":"大陆","v":"大陆"},{"n":"香港","v":"香港"},{"n":"台湾","v":"台湾"},{"n":"美国","v":"美国"},{"n":"法国","v":"法国"},{"n":"英国","v":"英国"},{"n":"日本","v":"日本"},{"n":"韩国","v":"韩国"},{"n":"德国","v":"德国"},{"n":"泰国","v":"泰国"},{"n":"印度","v":"印度"},{"n":"意大利","v":"意大利"},{"n":"西班牙","v":"西班牙"},{"n":"加拿大","v":"加拿大"},{"n":"其他","v":"其他"}]}, - {"key":"year","name":"按年份","init":"","value":[{"n":"全部","v":""},{"n":"2026","v":"2026"},{"n":"2025","v":"2025"},{"n":"2024","v":"2024"},{"n":"2023","v":"2023"},{"n":"2022","v":"2022"},{"n":"2021","v":"2021"},{"n":"2020","v":"2020"},{"n":"2019","v":"2019"},{"n":"2018","v":"2018"},{"n":"2017","v":"2017"},{"n":"2016","v":"2016"},{"n":"2015","v":"2015"},{"n":"2014","v":"2014"},{"n":"2013","v":"2013"},{"n":"2012","v":"2012"},{"n":"2011","v":"2011"},{"n":"2010","v":"2010"}]}, - {"key":"lang","name":"按语言","init":"","value":[{"n":"全部","v":""},{"n":"国语","v":"国语"},{"n":"英语","v":"英语"},{"n":"粤语","v":"粤语"},{"n":"闽南语","v":"闽南语"},{"n":"韩语","v":"韩语"},{"n":"日语","v":"日语"},{"n":"法语","v":"法语"},{"n":"德语","v":"德语"},{"n":"其它","v":"其它"}]}, - {"key":"sort","name":"按排序","init":"time","value":[{"n":"时间","v":"time"},{"n":"人气","v":"hits"},{"n":"评分","v":"score"}]} - ], - "2": [ - {"key":"class","name":"按剧情","init":"","value":[{"n":"全部","v":""},{"n":"古装","v":"古装"},{"n":"战争","v":"战争"},{"n":"青春偶像","v":"青春偶像"},{"n":"喜剧","v":"喜剧"},{"n":"家庭","v":"家庭"},{"n":"犯罪","v":"犯罪"},{"n":"动作","v":"动作"},{"n":"奇幻","v":"奇幻"},{"n":"剧情","v":"剧情"},{"n":"历史","v":"历史"},{"n":"经典","v":"经典"},{"n":"乡村","v":"乡村"},{"n":"情景","v":"情景"},{"n":"商战","v":"商战"},{"n":"网剧","v":"网剧"},{"n":"其他","v":"其他"}]}, - {"key":"area","name":"按地区","init":"","value":[{"n":"全部","v":""},{"n":"内地","v":"内地"},{"n":"韩国","v":"韩国"},{"n":"香港","v":"香港"},{"n":"台湾","v":"台湾"},{"n":"日本","v":"日本"},{"n":"美国","v":"美国"},{"n":"泰国","v":"泰国"},{"n":"英国","v":"英国"},{"n":"新加坡","v":"新加坡"},{"n":"其他","v":"其他"}]}, - {"key":"year","name":"按年份","init":"","value":[{"n":"全部","v":""},{"n":"2026","v":"2026"},{"n":"2025","v":"2025"},{"n":"2024","v":"2024"},{"n":"2023","v":"2023"},{"n":"2022","v":"2022"},{"n":"2021","v":"2021"},{"n":"2020","v":"2020"},{"n":"2019","v":"2019"},{"n":"2018","v":"2018"},{"n":"2017","v":"2017"},{"n":"2016","v":"2016"},{"n":"2015","v":"2015"},{"n":"2014","v":"2014"},{"n":"2013","v":"2013"},{"n":"2012","v":"2012"},{"n":"2011","v":"2011"},{"n":"2010","v":"2010"}]}, - {"key":"lang","name":"按语言","init":"","value":[{"n":"全部","v":""},{"n":"国语","v":"国语"},{"n":"英语","v":"英语"},{"n":"粤语","v":"粤语"},{"n":"闽南语","v":"闽南语"},{"n":"韩语","v":"韩语"},{"n":"日语","v":"日语"},{"n":"其它","v":"其它"}]}, - {"key":"sort","name":"按排序","init":"time","value":[{"n":"时间","v":"time"},{"n":"人气","v":"hits"},{"n":"评分","v":"score"}]} - ], - "5": [ - {"key":"class","name":"按剧情","init":"","value":[{"n":"全部","v":""},{"n":"真人秀","v":"真人秀"},{"n":"综艺","v":"综艺"},{"n":"脱口秀","v":"脱口秀"},{"n":"欧美综艺","v":"欧美综艺"},{"n":"日韩综艺","v":"日韩综艺"}]}, - {"key":"year","name":"按年份","init":"","value":[{"n":"全部","v":""},{"n":"2026","v":"2026"},{"n":"2025","v":"2025"},{"n":"2024","v":"2024"},{"n":"2023","v":"2023"},{"n":"2022","v":"2022"},{"n":"2021","v":"2021"},{"n":"2020","v":"2020"},{"n":"2019","v":"2019"},{"n":"2018","v":"2018"},{"n":"2017","v":"2017"},{"n":"2016","v":"2016"},{"n":"2015","v":"2015"},{"n":"2014","v":"2014"},{"n":"2013","v":"2013"},{"n":"2012","v":"2012"},{"n":"2011","v":"2011"},{"n":"2010","v":"2010"}]}, - {"key":"lang","name":"按语言","init":"","value":[{"n":"全部","v":""},{"n":"国语","v":"国语"},{"n":"英语","v":"英语"},{"n":"粤语","v":"粤语"},{"n":"闽南语","v":"闽南语"},{"n":"韩语","v":"韩语"},{"n":"日语","v":"日语"},{"n":"其它","v":"其它"}]}, - {"key":"sort","name":"按排序","init":"time","value":[{"n":"时间","v":"time"},{"n":"人气","v":"hits"},{"n":"评分","v":"score"}]} - ], - "4": [ - {"key":"year","name":"按年份","init":"","value":[{"n":"全部","v":""},{"n":"2026","v":"2026"},{"n":"2025","v":"2025"},{"n":"2024","v":"2024"},{"n":"2023","v":"2023"},{"n":"2022","v":"2022"},{"n":"2021","v":"2021"},{"n":"2020","v":"2020"},{"n":"2019","v":"2019"},{"n":"2018","v":"2018"},{"n":"2017","v":"2017"},{"n":"2016","v":"2016"},{"n":"2015","v":"2015"},{"n":"2014","v":"2014"},{"n":"2013","v":"2013"},{"n":"2012","v":"2012"},{"n":"2011","v":"2011"},{"n":"2010","v":"2010"}]}, - {"key":"lang","name":"按语言","init":"","value":[{"n":"全部","v":""},{"n":"国语","v":"国语"},{"n":"英语","v":"英语"},{"n":"粤语","v":"粤语"},{"n":"闽南语","v":"闽南语"},{"n":"韩语","v":"韩语"},{"n":"日语","v":"日语"},{"n":"其它","v":"其它"}]}, - {"key":"sort","name":"按排序","init":"time","value":[{"n":"时间","v":"time"},{"n":"人气","v":"hits"},{"n":"评分","v":"score"}]} - ], - "3": [ - {"key":"year","name":"按年份","init":"","value":[{"n":"全部","v":""},{"n":"2026","v":"2026"},{"n":"2025","v":"2025"},{"n":"2024","v":"2024"},{"n":"2023","v":"2023"},{"n":"2022","v":"2022"},{"n":"2021","v":"2021"},{"n":"2020","v":"2020"},{"n":"2019","v":"2019"},{"n":"2018","v":"2018"},{"n":"2017","v":"2017"},{"n":"2016","v":"2016"},{"n":"2015","v":"2015"},{"n":"2014","v":"2014"},{"n":"2013","v":"2013"},{"n":"2012","v":"2012"},{"n":"2011","v":"2011"},{"n":"2010","v":"2010"}]}, - {"key":"lang","name":"按语言","init":"","value":[{"n":"全部","v":""},{"n":"国语","v":"国语"},{"n":"英语","v":"英语"},{"n":"粤语","v":"粤语"},{"n":"闽南语","v":"闽南语"},{"n":"韩语","v":"韩语"},{"n":"日语","v":"日语"},{"n":"其它","v":"其它"}]}, - {"key":"sort","name":"按排序","init":"time","value":[{"n":"时间","v":"time"},{"n":"人气","v":"hits"},{"n":"评分","v":"score"}]} - ] - } - """ - ) - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes, "filters": self.filters} - - def homeVideoContent(self): - return {"list": []} - - def _stringify(self, value): - return "" if value is None else str(value) - - def _normalize_ext(self, extend): - if isinstance(extend, dict): - return extend - if not extend: - return {} - try: - return json.loads(str(extend)) - except Exception: - return {} - - def _build_url(self, path): - raw = self._stringify(path).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - if raw.startswith("/"): - return self.host + raw - return self.host + "/" + raw - - def _extract_site_path_id(self, href): - matched = re.search(r"/(detail/[^/?#]+)\.html", self._build_url(href)) - return matched.group(1) if matched else "" - - def _build_detail_request_url(self, vod_id): - value = self._stringify(vod_id).strip().strip("/") - return self._build_url(f"/{value}.html") if value else "" - - def _build_category_url(self, tid, pg, extend): - values = dict(self.filter_def.get(str(tid), {"cateId": str(tid), "sort": "time"})) - values.update(self._normalize_ext(extend)) - path = ( - f"show/{values.get('cateId', tid)}-{values.get('area', '')}-{values.get('sort', 'time')}-" - f"{values.get('class', '')}-{values.get('lang', '')}-{values.get('letter', '')}---{int(pg)}---" - f"{values.get('year', '')}" - ) - return self._build_url(path) - - def _request_html(self, path_or_url, referer=None): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - headers = dict(self.headers) - headers["Referer"] = referer or self.headers["Referer"] - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for card in root.xpath("//*[contains(@class,'myui-vodlist__box')]"): - href = ((card.xpath(".//*[contains(@class,'title')]//a[@href][1]/@href") or [""])[0]).strip() - title = ( - ((card.xpath(".//*[contains(@class,'title')]//a[@title][1]/@title") or [""])[0]).strip() - or self._clean_text("".join(card.xpath(".//*[contains(@class,'title')]//a[1]//text()"))) - ) - pic = ( - ((card.xpath(".//*[contains(@class,'lazyload')][1]/@data-original") or [""])[0]).strip() - or ((card.xpath(".//*[contains(@class,'lazyload')][1]/@src") or [""])[0]).strip() - or ((card.xpath(".//img[1]/@data-original") or [""])[0]).strip() - or ((card.xpath(".//img[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(card.xpath(".//*[contains(@class,'pic-text')][1]//text()"))) - vod_id = self._extract_site_path_id(href) - if not vod_id or not title or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - items = self._parse_cards(self._request_html(self._build_category_url(tid, pg, extend))) - return { - "list": items, - "page": page, - "limit": 12, - "total": page * 30 + len(items), - } - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._stringify(key).strip() - if not keyword: - return {"page": page, "total": 0, "list": []} - url = f"{self.host}/search/-------------.html?wd={quote(keyword)}" - items = self._parse_cards(self._request_html(url)) - return {"page": page, "total": len(items), "list": items} - - def _extract_detail_field(self, root, label, joiner=""): - if root is None: - return "" - nodes = root.xpath(f'.//*[contains(@class,"data")][.//*[contains(normalize-space(.), "{label}：")]]') - if not nodes: - return "" - anchor_values = [self._clean_text(text) for text in nodes[0].xpath(".//a//text()") if self._clean_text(text)] - if anchor_values: - return joiner.join(anchor_values) if joiner else "".join(anchor_values) - text = self._clean_text("".join(nodes[0].xpath(".//text()"))) - return text.split("：", 1)[-1].strip() if "：" in text else text - - def _normalize_disk_name(self, text): - value = self._clean_text(text).lower() - if "百度" in value: - return "baidu" - if "夸克" in value: - return "quark" - if value.startswith("uc") or "uc网盘" in value or "uc 网盘" in value: - return "uc" - if "阿里" in value or "aliyun" in value: - return "aliyun" - if "迅雷" in value: - return "xunlei" - return value or "netdisk" - - def _normalize_disk_name_from_url(self, value): - text = self._stringify(value).strip().lower() - if "pan.baidu.com" in text: - return "baidu" - if "pan.quark.cn" in text: - return "quark" - if "drive.uc.cn" in text: - return "uc" - if "alipan.com" in text or "aliyundrive.com" in text: - return "aliyun" - if "pan.xunlei.com" in text: - return "xunlei" - return "" - - def _disk_priority(self, name): - order = {"baidu": 1, "quark": 2, "uc": 3, "aliyun": 4, "xunlei": 5} - return order.get(name, 999) - - def _extract_netdisk_groups(self, html): - root = self.html(html) - if root is None: - return [] - grouped = {} - order_seen = [] - for row in root.xpath("//*[contains(@class,'text-muted') and contains(@class,'col-pd')]"): - raw_name = self._clean_text("".join(row.xpath(".//b[1]//text()"))).replace("：", "") - href = ((row.xpath(".//a[@href][1]/@href") or [""])[0]).strip() - if not href or not self._is_netdisk_url(href): - continue - disk_name = self._normalize_disk_name_from_url(href) or self._normalize_disk_name(raw_name) - title = self._clean_text("".join(row.xpath(".//a[1]//text()"))) or disk_name - if disk_name not in grouped: - grouped[disk_name] = [] - order_seen.append(disk_name) - links = {item.split("$", 1)[1] for item in grouped[disk_name]} - if href not in links: - grouped[disk_name].append(f"{title}${href}") - names = sorted(order_seen, key=self._disk_priority) - return [{"from": name, "urls": "#".join(grouped[name])} for name in names if grouped[name]] - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - if root is None: - return {"vod_id": vod_id, "vod_name": "", "vod_play_from": "", "vod_play_url": ""} - detail_root = (root.xpath("//*[contains(@class,'myui-content__detail')][1]") or [root])[0] - title = self._clean_text("".join(detail_root.xpath(".//*[contains(@class,'title')][1]//text()"))) - pic = ( - ((root.xpath("//*[contains(@class,'lazyload')][1]/@data-original") or [""])[0]).strip() - or ((root.xpath("//*[contains(@class,'myui-vodlist__thumb')]//img[1]/@src") or [""])[0]).strip() - ) - content = "" - for node in root.xpath("//*[contains(@class,'text-muted')]"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if "剧情简介" in text: - content = text.replace("剧情简介：", "").strip() - break - groups = self._extract_netdisk_groups(html) - return { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_content": content, - "vod_remarks": "", - "vod_year": self._extract_detail_field(detail_root, "年份"), - "vod_area": self._extract_detail_field(detail_root, "地区"), - "vod_class": self._extract_detail_field(detail_root, "分类"), - "vod_director": self._extract_detail_field(detail_root, "导演"), - "vod_actor": self._extract_detail_field(detail_root, "主演", joiner=","), - "vod_play_from": "$$$".join([item["from"] for item in groups]), - "vod_play_url": "$$$".join([item["urls"] for item in groups]), - } - - def detailContent(self, ids): - result = {"list": []} - for raw in ids: - vod_id = self._stringify(raw).strip() - if not vod_id: - continue - result["list"].append( - self._parse_detail_page(self._request_html(self._build_detail_request_url(vod_id)), vod_id) - ) - return result - - def _is_netdisk_url(self, value): - text = self._stringify(value).strip().lower() - return any( - token in text - for token in [ - "drive.uc.cn", - "pan.quark.cn", - "pan.baidu.com", - "pan.xunlei.com", - "alipan.com", - "aliyundrive.com", - ] - ) - - def playerContent(self, flag, id, vipFlags): - raw = self._stringify(id).strip() - if self._is_netdisk_url(raw): - return {"parse": 0, "playUrl": "", "url": raw} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/滴答影视.txt b/py/滴答影视.txt new file mode 100644 index 0000000..a8480d3 --- /dev/null +++ b/py/滴答影视.txt @@ -0,0 +1,15 @@ +// ignore +//@name:滴答影视 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:X6OZ47Yo+lR2hOna +//@ek:base64:SZUh3B/eS57BBT+fORW6GYX3yBh6PHPKLlFDDDvFbxDuJOc2XP7n7+2l303/xW77 +//@hash:sha256:88cf1e0d2f1f02fbc4ae3b00caa4c05877a1886e08c3a372b31aa3d922e52616 +//@sig:base64:YaHR7o9CzYmGVE/Ow0dYHY/WhtzorPFqpb0aSMiT4W9MlDzB2lirgXWIb3vHOb6Zagg76EKECYa8p9uL517cDQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/独播库.py b/py/独播库.py deleted file mode 100644 index 7e58a8b..0000000 --- a/py/独播库.py +++ /dev/null @@ -1,374 +0,0 @@ -# coding=utf-8 -import base64 -import json -import re -import sys -from urllib.parse import quote, unquote - -from lxml import etree - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "独播库" - self.host = "https://www.dbku.tv" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/124.0.0.0 Safari/537.36" - ) - } - self.categories = [ - {"type_name": "连续剧", "type_id": "index"}, - {"type_name": "电影", "type_id": "movie"}, - {"type_name": "综艺", "type_id": "variety"}, - {"type_name": "动漫", "type_id": "anime"}, - {"type_name": "港剧", "type_id": "hk"}, - {"type_name": "陆剧", "type_id": "luju"}, - ] - self.category_paths = { - "index": "/vodtype/2--------{pg}---.html", - "movie": "/vodtype/1--------{pg}---.html", - "variety": "/vodtype/3--------{pg}---.html", - "anime": "/vodtype/4--------{pg}---.html", - "hk": "/vodtype/20--------{pg}---.html", - "luju": "/vodtype/13--------{pg}---.html", - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, href): - raw = str(href or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - if raw.startswith("/"): - return self.host + raw - return self.host + "/" + raw - - def _extract_play_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"/vodplay/(\d+-\d+-\d+)\.html", raw) - if matched: - return matched.group(1) - if re.fullmatch(r"\d+-\d+-\d+", raw): - return raw - return "" - - def _extract_vod_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"/voddetail/(\d+)\.html", raw) - if matched: - return matched.group(1) - if re.fullmatch(r"\d+", raw): - return raw - return "" - - def _build_detail_request_url(self, id_or_url): - raw = str(id_or_url or "").strip() - if not raw: - return "" - vod_id = self._extract_vod_id(raw) - if vod_id: - return f"{self.host}/voddetail/{vod_id}.html" - return self._build_url(raw) - - def _build_play_request_url(self, id_or_url): - raw = str(id_or_url or "").strip() - if not raw: - return "" - play_id = self._extract_play_id(raw) - if play_id: - return f"{self.host}/vodplay/{play_id}.html" - return self._build_url(raw) - - def _parse_list_cards(self, html): - root = self.html(html) - results = [] - if root is None: - return results - - cards = root.xpath("//*[contains(@class,'myui-vodlist__box')]") - seen = set() - for card in cards: - href = "" - title = "" - pic = "" - for anchor in card.xpath(".//a[@href]"): - raw_href = (anchor.xpath("./@href") or [""])[0].strip() - if "/voddetail/" in raw_href: - href = self._extract_vod_id(raw_href) - title = ( - (anchor.xpath("./@title") or [""])[0].strip() - or "".join(anchor.xpath(".//text()")).strip() - ) - pic = ( - (anchor.xpath("./@data-original") or [""])[0].strip() - or (anchor.xpath("./@src") or [""])[0].strip() - ) - break - if not href or href in seen or not title: - continue - - remarks = "".join(card.xpath(".//*[contains(@class,'pic-text')][1]//text()")).strip() - seen.add(href) - results.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return results - - def _request_html(self, path_or_url, expect_xpath=None, referer=None): - target = path_or_url if path_or_url.startswith("http") else self._build_url(path_or_url) - headers = dict(self.headers) - headers["Referer"] = referer or self.host - headers["Origin"] = self.host - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return "" - html = response.text or "" - if expect_xpath: - root = self.html(html) - if root is None or not root.xpath(expect_xpath): - return "" - return html - - def _parse_cards_from_nodes(self, nodes): - results = [] - seen = set() - for card in nodes: - snippet = self._parse_list_cards(etree.tostring(card, encoding="unicode")) - for item in snippet: - if item["vod_id"] in seen: - continue - seen.add(item["vod_id"]) - results.append(item) - return results - - def _parse_search_cards(self, html): - root = self.html(html) - if root is None: - return [] - search_list = root.xpath("//*[@id='searchList']") - if search_list: - cards = search_list[0].xpath(".//*[contains(@class,'myui-vodlist__box')]") - parsed = self._parse_cards_from_nodes(cards) - if parsed: - return parsed - return self._parse_list_cards(html) - - def _page_result(self, items, pg): - page = int(pg) - return { - "list": items, - "page": page, - "limit": len(items), - "total": page * 30 + len(items), - } - - def categoryContent(self, tid, pg, filter, extend): - path = self.category_paths.get(tid, self.category_paths["index"]).format(pg=pg) - html = self._request_html(path, expect_xpath="//*[contains(@class,'myui-vodlist__box')]") - return self._page_result(self._parse_list_cards(html), pg) - - def searchContent(self, key, quick, pg="1"): - path = "/vodsearch/-------------.html?wd={0}&submit=".format(quote(key)) - html = self._request_html(path, expect_xpath="//*[@id='searchList']|//*[contains(@class,'myui-vodlist__box')]") - return self._page_result(self._parse_search_cards(html), pg) - - def _extract_text_by_prefix(self, html, prefixes): - texts = re.findall(r">([^<>]+)<", html) - for text in texts: - clean = text.strip() - for prefix in prefixes: - if clean.startswith(prefix): - return clean.split("：", 1)[-1].strip() - return "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _extract_detail_text(self, detail_root, html, label, joiner=""): - value = self._extract_detail_field(detail_root, label, joiner=joiner) - if value: - return value - return self._extract_text_by_prefix(html, [f"{label}："]) - - def _extract_detail_field(self, detail_root, label, joiner=""): - if detail_root is None: - return "" - nodes = detail_root.xpath(f'.//span[contains(normalize-space(.), "{label}：")]') - if not nodes: - return "" - label_node = nodes[0] - values = [] - if self._clean_text(label_node.tail): - values.append(self._clean_text(label_node.tail)) - for sibling in label_node.itersiblings(): - classes = " ".join(sibling.xpath("./@class")) - if sibling.tag == "span" and "text-muted" in classes: - break - if sibling.tag == "span" and "split-line" in classes: - continue - if sibling.tag == "a" and (sibling.xpath("./@href") or [""])[0].startswith("#"): - break - text = self._clean_text("".join(sibling.xpath(".//text()"))) - if text: - values.append(text) - tail = self._clean_text(sibling.tail) - if tail: - values.append(tail) - - cleaned = [] - for value in values: - if value and value not in cleaned: - cleaned.append(value) - if joiner: - return joiner.join(cleaned) - return self._clean_text("".join(cleaned)) - - def _parse_detail_page(self, html, vod_id): - root = self.html(html) - detail_root = ( - root.xpath("//*[contains(concat(' ', normalize-space(@class), ' '), ' myui-content__detail ')][1]") - or [root] - )[0] - title = ((detail_root.xpath(".//*[contains(@class,'title')][1]//text()") or [""])[0]).strip() - pic = ( - (root.xpath("//*[contains(@class,'myui-content__thumb')]//img/@data-original") or [""])[0].strip() - or (root.xpath("//*[contains(@class,'myui-content__thumb')]//img/@src") or [""])[0].strip() - ) - content = self._extract_detail_field(detail_root, "简介") or "".join( - root.xpath("//*[contains(@class,'data')][1]//text()") - ).strip() - - episodes = [] - seen = set() - for href, label in re.findall( - r'<a[^>]+href=["\']([^"\']*/vodplay/\d+-\d+-\d+\.html[^"\']*)["\'][^>]*>([\s\S]*?)</a>', - html, - re.I, - ): - play_id = self._extract_play_id(href) - name = re.sub(r"<[^>]*>", "", label).strip() - if not play_id or not name or "立即播放" in name or play_id in seen: - continue - seen.add(play_id) - episodes.append(f"{name}${play_id}") - - vod = { - "vod_id": vod_id, - "path": self._build_detail_request_url(vod_id), - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_tag": "", - "vod_time": self._extract_detail_text(detail_root, html, "更新"), - "vod_remarks": self._clean_text( - ((detail_root.xpath('.//*[@id="rating"]//*[contains(@class,"branch")][1]//text()') or [""])[0]).strip() - or ((detail_root.xpath('.//*[@id="ratewords"][1]//text()') or [""])[0]).strip() - ), - "vod_play_from": "独播库", - "vod_play_url": "#".join(episodes), - "type_name": self._extract_detail_text(detail_root, html, "分类"), - "vod_content": content, - "vod_year": self._extract_detail_text(detail_root, html, "年份"), - "vod_area": self._extract_detail_text(detail_root, html, "地区"), - "vod_lang": "", - "vod_director": self._extract_detail_text(detail_root, html, "导演", joiner=","), - "vod_actor": self._extract_detail_text(detail_root, html, "主演", joiner=","), - } - return {"list": [vod]} - - def detailContent(self, ids): - vod_id = ids[0] - html = self._request_html( - self._build_detail_request_url(vod_id), - expect_xpath="//*[contains(@class,'title')]|//a[contains(@href,'/vodplay/')]", - ) - return self._parse_detail_page(html, vod_id) - - def _parse_player_data(self, html): - matched = re.search(r"var\s+player_data\s*=\s*(\{[\s\S]*?\})\s*;?\s*</script>", html, re.I) - if not matched: - matched = re.search(r"var\s+player_[^=]*\s*=\s*(\{[\s\S]*?\})\s*;?\s*</script>", html, re.I) - if not matched: - return None - try: - return json.loads(matched.group(1)) - except Exception: - return None - - def _decode_play_url_by_encrypt(self, value, encrypt): - raw = str(value or "") - mode = int(encrypt or 0) - if not raw: - return "" - try: - if mode == 1: - return unquote(raw) - if mode == 2: - decoded = base64.b64decode(raw).decode("utf-8") - return unquote(decoded) - if mode == 3: - text = raw[8:] if len(raw) > 16 else raw - text = base64.b64decode(text).decode("utf-8") - if len(text) > 16: - text = text[8:-8] - return text - return raw - except Exception: - return raw - - def _build_player_headers(self, referer): - return { - "User-Agent": self.headers["User-Agent"], - "Referer": referer, - } - - def playerContent(self, flag, id, vipFlags): - current = id - for _ in range(3): - request_url = self._build_play_request_url(current) - html = self._request_html(request_url, referer=self.host) - data = self._parse_player_data(html) - if not data: - return {"parse": 0, "playUrl": "", "url": ""} - decoded = self._decode_play_url_by_encrypt(data.get("url", ""), data.get("encrypt", 0)) - play_url = self._build_url(decoded) - if not play_url: - return {"parse": 0, "playUrl": "", "url": ""} - if self.host in play_url and "/vodplay/" in play_url and play_url != current: - current = play_url - continue - return { - "parse": 0, - "playUrl": "", - "url": play_url, - "header": self._build_player_headers(request_url), - } - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/独播库.txt b/py/独播库.txt new file mode 100644 index 0000000..ed40b80 --- /dev/null +++ b/py/独播库.txt @@ -0,0 +1,15 @@ +// ignore +//@name:独播库 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:x/ZUk2NRi9fhpUq0 +//@ek:base64:IcnaY44RdUWv8hCNcPuWIoxs87QI2mPolTxaI2bTsQZHu+nSTP+5IfAcO0vYaD/L +//@hash:sha256:5ebe970ec094c5f1c5c956194a61c394d5dda672122a9bea2dfae4a14a450dbb +//@sig:base64:hnxMt93GzV46Qd9XjyXSv5vlgQwEyUYJeXXvkZNq44D/GysudOqFW/M3O72j2yz9zz4Y7eZKvo51WRPCEmaLCQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/玩偶哥哥.py b/py/玩偶哥哥.py deleted file mode 100644 index 300692b..0000000 --- a/py/玩偶哥哥.py +++ /dev/null @@ -1,270 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "玩偶哥哥" - self.host = "http://wogg.xxooo.cf" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.categories = [ - {"type_id": "1", "type_name": "玩偶电影"}, - {"type_id": "2", "type_name": "玩偶剧集"}, - {"type_id": "3", "type_name": "玩偶动漫"}, - {"type_id": "4", "type_name": "玩偶综艺"}, - {"type_id": "44", "type_name": "臻彩视界"}, - {"type_id": "6", "type_name": "玩偶短剧"}, - {"type_id": "5", "type_name": "玩偶音乐"}, - {"type_id": "46", "type_name": "玩偶纪录"}, - ] - self.pan_patterns = [ - ("baidu", "百度资源", r"pan\.baidu\.com|yun\.baidu\.com"), - ("a139", "139资源", r"yun\.139\.com"), - ("a189", "天翼资源", r"cloud\.189\.cn"), - ("a123", "123资源", r"123684\.com|123865\.com|123912\.com|123pan\.com"), - ("a115", "115资源", r"115\.com"), - ("quark", "夸克资源", r"pan\.quark\.cn"), - ("xunlei", "迅雷资源", r"pan\.xunlei\.com"), - ("aliyun", "阿里资源", r"aliyundrive\.com|alipan\.com"), - ("uc", "UC资源", r"drive\.uc\.cn"), - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _fix_img_url(self, img_url): - raw = str(img_url or "").strip() - if not raw: - return "" - if raw.startswith("/db.php?url="): - return self._build_url(raw) - if re.search(r"^https?://[^/]*gimg\d*\.baidu\.com/gimg/", raw, re.I) and "src=data:image/" in raw: - return "" - return raw - - def _detect_pan_type(self, url): - raw = str(url or "").strip() - for pan_type, title, pattern in self.pan_patterns: - if re.search(pattern, raw, re.I): - return pan_type, title - return "", "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for node in root.xpath( - "//*[@id='main']//*[contains(concat(' ', normalize-space(@class), ' '), ' module-item ')]" - ): - href = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//a[@href])[1]/@href") or [""])[0]).strip() - title = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@alt])[1]/@alt") or [""])[0]).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-text')])[1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(self._fix_img_url(pic)), - "vod_remarks": remarks, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_url(f"/vodshow/{tid}--------{int(pg)}---.html") - return self._page_result(self._parse_cards(self._request_html(url)), pg) - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - page = int(pg) - if not keyword: - return {"page": page, "total": 0, "list": []} - - url = self._build_url(f"/vodsearch/-------------.html?wd={quote(keyword)}&page={page}") - root = self.html(self._request_html(url)) - if root is None: - return {"page": page, "total": 0, "list": []} - - items = [] - for node in root.xpath("//*[contains(@class,'module-search-item')]"): - href = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@href")).strip() - title = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@title")).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'video-serial')][1]//text()")) - or "".join(node.xpath(".//*[contains(@class,'module-item-text')][1]//text()")) - ) - if not href or not title: - continue - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(self._fix_img_url(pic)), - "vod_remarks": remarks, - } - ) - return {"page": page, "total": len(items), "list": items} - - def _parse_detail_page(self, vod_id, html): - root = self.html(html) - if root is None: - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - detail = { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath("//*[contains(@class,'page-title')][1]//text()"))), - "vod_pic": self._build_url( - self._fix_img_url( - ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@data-src") or [""])[0] - ).strip() - or ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@src") or [""])[0] - ).strip() - ) - ), - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - for label_node in root.xpath("//*[contains(@class,'video-info-itemtitle')]"): - key = self._clean_text("".join(label_node.xpath(".//text()"))) - sibling = label_node.getnext() - if sibling is None: - continue - values = [self._clean_text(text) for text in sibling.xpath(".//a//text()")] - joined = ",".join([value for value in values if value]) - text_value = self._clean_text("".join(sibling.xpath(".//text()"))) - if "年代" in key: - detail["vod_year"] = joined or text_value - elif "导演" in key: - detail["vod_director"] = joined or text_value - elif "主演" in key: - detail["vod_actor"] = joined or text_value - elif "剧情" in key: - detail["vod_content"] = text_value - - pan_urls = [] - for node in root.xpath("//*[contains(@class,'module-row-info')]//p"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if text: - pan_urls.append(text) - detail["pan_urls"] = pan_urls - return detail - - def _build_pan_lines(self, detail): - lines = [] - seen = set() - for url in detail.get("pan_urls", []): - pan_type, title = self._detect_pan_type(url) - if not pan_type or url in seen: - continue - seen.add(url) - lines.append((self.pan_priority.get(pan_type, 999), f"{pan_type}#玩偶哥哥", f"{title}${url}")) - lines.sort(key=lambda item: item[0]) - return [(item[1], item[2]) for item in lines] - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail = self._parse_detail_page(vod_id, self._request_html(self._build_url(vod_id))) - lines = self._build_pan_lines(detail) - result["list"].append( - { - "vod_id": vod_id, - "vod_name": detail["vod_name"], - "vod_pic": detail["vod_pic"], - "vod_year": detail["vod_year"], - "vod_director": detail["vod_director"], - "vod_actor": detail["vod_actor"], - "vod_content": detail["vod_content"], - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - pan_type, _ = self._detect_pan_type(id) - if pan_type: - return {"parse": 0, "playUrl": "", "url": id} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/玩偶哥哥.txt b/py/玩偶哥哥.txt new file mode 100644 index 0000000..4ab573f --- /dev/null +++ b/py/玩偶哥哥.txt @@ -0,0 +1,15 @@ +// ignore +//@name:玩偶哥哥 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:XQWKmtn3aHAMfOVE +//@ek:base64:96GFBviR9qNQJhOqI4lhpm6DTqpgVpM5Cr6k49ymFpC6ryDTiyPlcaxWsIsWJOcQ +//@hash:sha256:340cf054e3f0c608577e25549948d741e1bbadcb1bb3439aabc38467441cf5b4 +//@sig:base64:puqsNFw24wjSUWantOrIwUFf4YJgwYmNY1jis1kqdF8rA54obfJF4zJXgC7s80DhoGaMf9nCqU0Xf3F1S3szDA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/玩偶聚合.py b/py/玩偶聚合.py deleted file mode 100644 index e5db904..0000000 --- a/py/玩偶聚合.py +++ /dev/null @@ -1,747 +0,0 @@ -# coding=utf-8 -import base64 -import json -import os -import re -import sys -from urllib.parse import quote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "玩偶聚合" - self.filter_root = os.path.join(os.path.dirname(__file__), "../筛选") - self.recommend_page_size = 20 - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ) - } - self.site_priority = [ - "wanou", - "muou", - "labi", - "zhizhen", - "erxiao", - "huban", - "kuaiying", - "shandian", - "ouge", - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - self.sites = [ - { - "id": "wanou", - "name": "玩偶", - "domains": ["https://wogg.xxooo.cf", "https://www.wogg.net"], - "filter_files": ["wogg.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "category_url": "/vodshow/{categoryId}--------{page}---.html", - "category_url_with_filters": "/vodshow/{categoryId}-{area}-{by}-{class}-----{page}---{year}.html", - "search_url": "/vodsearch/-------------.html?wd={keyword}&page={page}", - "default_categories": [ - ("44", "臻彩"), - ("1", "电影"), - ("2", "电视剧"), - ("3", "动漫"), - ("4", "综艺"), - ("5", "音乐"), - ("6", "短剧"), - ("46", "纪录片"), - ], - }, - { - "id": "muou", - "name": "木偶", - "domains": ["https://www.muou.site", "https://www.muou.asia", "https://666.666291.xyz"], - "filter_files": ["mogg.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "default_categories": [ - ("25", "臻选"), - ("1", "电影"), - ("2", "电视剧"), - ("3", "动漫"), - ("4", "纪录片"), - ("29", "综艺"), - ("30", "原盘"), - ], - }, - { - "id": "labi", - "name": "蜡笔", - "domains": ["http://xiaocgege.shop", "http://fmao.shop"], - "filter_files": ["labi.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "default_categories": [ - ("29", "臻彩"), - ("1", "电影"), - ("2", "电视剧"), - ("3", "动漫"), - ("4", "综艺"), - ("5", "短剧"), - ("24", "蜡笔4K"), - ], - }, - { - "id": "zhizhen", - "name": "至臻", - "domains": ["http://www.miqk.cc", "https://www.mihdr.top", "https://mihdr.top"], - "filter_files": ["zhizhen.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "default_categories": [ - ("26", "臻彩"), - ("1", "电影"), - ("2", "电视剧"), - ("3", "动漫"), - ("4", "综艺"), - ("5", "短剧"), - ("24", "老剧"), - ], - }, - { - "id": "erxiao", - "name": "二小", - "domains": [ - "https://www.2xiaopan.top", - "https://www.erxiaozhan.top", - "https://www.wexwp.cc", - ], - "filter_files": ["erxiao.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "default_categories": [ - ("4", "臻彩"), - ("1", "电影"), - ("2", "电视剧"), - ("3", "动漫"), - ("21", "综艺"), - ], - }, - # { - # "id": "huban", - # "name": "虎斑", - # "domains": ["http://154.222.27.33:20720", "http://xhban.xyz:20720", "http://103.45.162.207:20720"], - # "filter_files": ["huban.json"], - # "list_xpath": "//*[contains(@class,'module-item')]", - # "search_xpath": "//*[contains(@class,'module-search-item')]", - # "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - # "default_categories": [ - # ("6", "臻彩"), - # ("1", "电影"), - # ("2", "电视剧"), - # ("3", "综艺"), - # ("4", "动漫"), - # ("5", "短剧"), - # ("30", "115网盘"), - # ], - # }, - { - "id": "kuaiying", - "name": "快映", - "domains": ["http://154.201.83.50:12512", "http://xsayang.fun:12512"], - "filter_files": ["xiaoban.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "default_categories": [ - ("5", "臻彩"), - ("1", "电影"), - ("2", "电视剧"), - ("3", "综艺"), - ("4", "动漫"), - ("6", "短剧"), - ("30", "115"), - ("35", "123"), - ("36", "天移迅"), - ], - }, - { - "id": "shandian", - "name": "闪电", - "domains": ["https://sd.sduc.site"], - "filter_files": ["shandian.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "default_categories": [ - ("1", "电影"), - ("2", "电视剧"), - ("3", "综艺"), - ("4", "动漫"), - ("30", "短剧"), - ], - }, - { - "id": "ouge", - "name": "欧哥", - "domains": ["https://woog.nxog.eu.org"], - "filter_files": ["ouge.json"], - "list_xpath": "//*[contains(@class,'module-item')]", - "search_xpath": "//*[contains(@class,'module-search-item')]", - "detail_pan_xpath": "//*[contains(@class,'module-row-info')]//p", - "default_categories": [ - ("1", "电影"), - ("2", "电视剧"), - ("3", "动漫"), - ("4", "综艺"), - ("5", "短剧"), - ("21", "综合"), - ], - }, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeVideoContent(self): - return {"list": []} - - def _load_local_filter_groups(self, site): - groups = [] - for filename in site.get("filter_files", []): - if not filename: - continue - file_path = os.path.join(self.filter_root, filename) - if not os.path.exists(file_path): - continue - try: - with open(file_path, "r", encoding="utf-8") as handle: - raw = json.load(handle) - except Exception: - continue - merged = {} - for category_groups in raw.values() if isinstance(raw, dict) else []: - if not isinstance(category_groups, list): - continue - for group in category_groups: - key = str(group.get("key") or "").strip() - if not key or key == "categoryId": - continue - bucket = merged.setdefault( - key, - { - "key": key, - "name": str(group.get("name") or key), - "init": str(group.get("init") or ""), - "value": [], - }, - ) - for item in group.get("value", []): - value = str(item.get("v") if isinstance(item, dict) else "") - name = str(item.get("n") if isinstance(item, dict) else "") - if not name: - continue - if not any(existing.get("v") == value for existing in bucket["value"]): - bucket["value"].append({"n": name, "v": value}) - for group in merged.values(): - if not any(item.get("v") == "" for item in group["value"]): - group["value"].insert(0, {"n": "全部", "v": ""}) - groups.append(group) - return groups - - def _build_site_filters(self, site): - groups = [ - { - "key": "categoryId", - "name": "分类", - "init": site["default_categories"][0][0], - "value": [{"n": "全部", "v": ""}] - + [{"n": name, "v": cid} for cid, name in site["default_categories"]], - } - ] - groups.extend(self._load_local_filter_groups(site)) - return groups - - def homeContent(self, filter): - classes = [{"type_id": "site_recommend", "type_name": "推荐"}] - classes.extend({"type_id": f"site_{site['id']}", "type_name": site["name"]} for site in self.sites) - filters = { - "site_recommend": [ - { - "key": "recommendSite", - "name": "站点", - "init": "all", - "value": [{"n": "全部", "v": "all"}] - + [{"n": site["name"], "v": site["id"]} for site in self.sites], - } - ] - } - filters.update({f"site_{site['id']}": self._build_site_filters(site) for site in self.sites}) - return {"class": classes, "filters": filters} - - def _encode_site_vod_id(self, site_id, path): - return f"site:{site_id}:{path}" - - def _decode_site_vod_id(self, value): - prefix, site_id, path = str(value).split(":", 2) - if prefix != "site": - raise ValueError("not site vod id") - return {"site": site_id, "path": path} - - def _encode_aggregate_vod_id(self, payload): - raw = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8") - return "agg:" + base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=") - - def _decode_aggregate_vod_id(self, value): - encoded = str(value)[4:] - padded = encoded + "=" * (-len(encoded) % 4) - return json.loads(base64.urlsafe_b64decode(padded.encode("utf-8")).decode("utf-8")) - - def _normalize_title(self, value): - text = str(value or "").lower() - text = re.sub(r"(4k|hdr|2160p|1080p|720p|玩偶|木偶|蜡笔)", "", text, flags=re.I) - text = re.sub(r"[\s\-_.·,，。!！?:：()（）\[\]]+", "", text) - return text - - def _is_same_title(self, left, right): - left_year = str(left.get("vod_year") or "").strip() - right_year = str(right.get("vod_year") or "").strip() - if left_year and right_year and left_year != right_year: - return False - return self._normalize_title(left.get("vod_name")) == self._normalize_title(right.get("vod_name")) - - def _get_site(self, site_id): - for site in self.sites: - if site["id"] == site_id: - return site - return None - - def _build_absolute_url(self, base, path): - raw = str(path or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return str(base).rstrip("/") + "/" + raw.lstrip("/") - - def _class_xpath(self, class_name): - return f"contains(concat(' ', normalize-space(@class), ' '), ' {class_name} ')" - - def _has_class(self, node, class_name): - classes = f" {str(node.get('class') or '').strip()} " - return f" {class_name} " in classes - - def _build_category_url(self, site, category_id, pg, extend): - values = dict(extend or {}) - values.setdefault("categoryId", category_id) - values.setdefault("area", "") - values.setdefault("by", values.get("sort", "")) - values.setdefault("class", "") - values.setdefault("year", "") - if site.get("category_url_with_filters") and any(values.get(key) for key in ("area", "by", "class", "year")): - path = site["category_url_with_filters"].format( - **{ - "categoryId": values["categoryId"], - "area": quote(str(values["area"])), - "by": quote(str(values["by"])), - "class": quote(str(values["class"])), - "page": int(pg), - "year": quote(str(values["year"])), - } - ) - else: - template = site.get("category_url") or "/index.php/vod/show/id/{categoryId}/page/{page}.html" - path = template.format(categoryId=values["categoryId"], page=int(pg)) - return self._build_absolute_url(site["domains"][0], path) - - def _request_with_failover(self, site, path_or_url, referer=None): - last_error = None - for index, domain in enumerate(list(site["domains"])): - target = path_or_url if str(path_or_url).startswith("http") else self._build_absolute_url(domain, path_or_url) - try: - headers = dict(self.headers) - headers["Referer"] = referer or self._build_absolute_url(domain, "/") - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code == 200 and response.text: - if index > 0: - site["domains"].insert(0, site["domains"].pop(index)) - return response.text - except Exception as exc: - last_error = exc - raise RuntimeError(str(last_error or "all domains failed")) - - def _parse_cards(self, site, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - pic_box_xpath = self._class_xpath("module-item-pic") - text_xpath = self._class_xpath("module-item-text") - for card in root.xpath(site["list_xpath"]): - if not self._has_class(card, "module-item"): - continue - href = ((card.xpath(".//a[@href][1]/@href") or [""])[0]).strip() - title = ( - ((card.xpath(".//img[@alt][1]/@alt") or [""])[0]).strip() - or ((card.xpath(".//a[@title][1]/@title") or [""])[0]).strip() - ) - pic = ( - ((card.xpath(f".//*[{pic_box_xpath}]//img[1]/@data-src") or [""])[0]).strip() - or ((card.xpath(f".//*[{pic_box_xpath}]//img[1]/@src") or [""])[0]).strip() - ) - remarks = "".join(card.xpath(f".//*[{text_xpath}][1]//text()")).strip() - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": self._encode_site_vod_id(site["id"], href), - "vod_name": title, - "vod_pic": self._build_absolute_url(site["domains"][0], pic), - "vod_remarks": remarks, - "vod_year": "", - "_site": site["id"], - "_detail_path": href, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - site_id = str(tid).replace("site_", "", 1) - values = extend if isinstance(extend, dict) else {} - if site_id == "recommend": - recommend_site_id = str(values.get("recommendSite") or "all") - candidates = self.sites if recommend_site_id == "all" else [site for site in self.sites if site["id"] == recommend_site_id] - merged = [] - for site in candidates: - for item in self._fetch_site_home_recommend(site): - matched = None - for existing in merged: - if self._is_same_title(existing, item): - matched = existing - break - if matched is None: - source_name = site["name"] - remarks = str(item.get("vod_remarks") or "").strip() - tagged = dict(item) - tagged["vod_remarks"] = f"[{source_name}] {remarks}".strip() - merged.append(tagged) - page = int(pg) - start = max(page - 1, 0) * self.recommend_page_size - end = start + self.recommend_page_size - paged = merged[start:end] - return {"list": paged, "page": page, "limit": len(paged), "total": len(merged)} - - site = self._get_site(site_id) - category_id = values.get("categoryId") or site["default_categories"][0][0] - html = self._request_with_failover(site, self._build_category_url(site, category_id, pg, values)) - items = self._parse_cards(site, html) - return {"list": items, "page": int(pg), "limit": len(items), "total": int(pg) * 20 + len(items)} - - def _site_rank(self, site_id): - try: - return self.site_priority.index(site_id) - except ValueError: - return 999 - - def _parse_search_cards(self, site, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - xpath = site.get("search_xpath") or site["list_xpath"] - video_serial_xpath = self._class_xpath("video-serial") - text_xpath = self._class_xpath("module-item-text") - for card in root.xpath(xpath): - if "module-search-item" in xpath and not self._has_class(card, "module-search-item"): - continue - href = ( - ((card.xpath(f".//*[{video_serial_xpath}][1]/@href") or [""])[0]).strip() - or ((card.xpath(".//*[@href][1]/@href") or [""])[0]).strip() - ) - title = ( - ((card.xpath(f".//*[{video_serial_xpath}][1]/@title") or [""])[0]).strip() - or ((card.xpath(".//img[@alt][1]/@alt") or [""])[0]).strip() - or ((card.xpath(".//*[@title][1]/@title") or [""])[0]).strip() - ) - pic = ( - ((card.xpath(".//img[@data-src][1]/@data-src") or [""])[0]).strip() - or ((card.xpath(".//img[@src][1]/@src") or [""])[0]).strip() - ) - remarks = "".join(card.xpath(f".//*[{text_xpath}][1]//text()")).strip() - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": self._encode_site_vod_id(site["id"], href), - "vod_name": title, - "vod_pic": self._build_absolute_url(site["domains"][0], pic), - "vod_remarks": remarks, - "vod_year": "", - "_site": site["id"], - "_detail_path": href, - } - ) - return items - - def _fetch_site_search(self, site, keyword, pg): - template = site.get("search_url") or "/index.php/vod/search/page/{page}/wd/{keyword}.html" - search_path = template.format(keyword=quote(str(keyword)), page=int(pg)) - html = self._request_with_failover(site, search_path) - return self._parse_search_cards(site, html) - - def _fetch_site_home_recommend(self, site, limit=30): - html = self._request_with_failover(site, "/") - items = self._parse_cards(site, html) - return items[:limit] - - def _aggregate_search_results(self, items): - groups = [] - for item in items: - matched_group = None - for group in groups: - if self._is_same_title(group[0], item): - matched_group = group - break - if matched_group is None: - groups.append([item]) - else: - matched_group.append(item) - - result = [] - for group in groups: - group.sort(key=lambda item: self._site_rank(item["_site"])) - primary = group[0] - payload = [ - { - "site": item["_site"], - "path": item["_detail_path"], - "name": item.get("vod_name", ""), - "year": item.get("vod_year", ""), - } - for item in group - ] - result.append( - { - "vod_id": self._encode_aggregate_vod_id(payload), - "vod_name": primary["vod_name"], - "vod_pic": primary.get("vod_pic", ""), - "vod_remarks": primary.get("vod_remarks", ""), - "vod_year": primary.get("vod_year", ""), - } - ) - return result - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = str(key or "").strip() - if not keyword: - return {"page": page, "total": 0, "list": []} - - all_items = [] - for site in self.sites: - try: - all_items.extend(self._fetch_site_search(site, keyword, page)) - except Exception: - continue - - merged = self._aggregate_search_results(all_items) - return {"page": page, "total": len(merged), "list": merged} - - def _detect_pan_type(self, url): - value = str(url or "").lower() - if "pan.baidu.com" in value: - return "baidu", "百度资源" - if "quark.cn" in value: - return "quark", "夸克资源" - if "uc.cn" in value: - return "uc", "UC资源" - if "alipan.com" in value or "aliyundrive.com" in value: - return "aliyun", "阿里资源" - if "xunlei.com" in value: - return "xunlei", "迅雷资源" - if "123pan.com" in value: - return "a123", "123资源" - if "115.com" in value or "115cdn.com" in value: - return "a115", "115资源" - if "cloud.189.cn" in value or "189.cn" in value: - return "a189", "天翼资源" - if "yun.139.com" in value or "139.com" in value: - return "a139", "移动云资源" - return "", "" - - def _join_next_sibling_links(self, root, label): - values = [] - labels = root.xpath(f"//*[contains(@class,'video-info-itemtitle') and contains(normalize-space(.), '{label}')]") - for node in labels: - sibling = node.getnext() - if sibling is None: - continue - for text in sibling.xpath(".//a/text()"): - clean = str(text).strip() - if clean: - values.append(clean) - unique = [] - for value in values: - if value not in unique: - unique.append(value) - return ",".join(unique) - - def _join_next_sibling_text(self, root, label): - labels = root.xpath(f"//*[contains(@class,'video-info-itemtitle') and contains(normalize-space(.), '{label}')]") - for node in labels: - sibling = node.getnext() - if sibling is None: - continue - text = "".join(sibling.xpath(".//text()")).strip() - if text: - return text - return "" - - def _parse_detail_page(self, site, detail_path, html): - root = self.html(html) - if root is None: - return { - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - "_site_name": site["name"], - } - - title = "".join(root.xpath("//*[contains(@class,'page-title')][1]//text()")).strip() - pic = ((root.xpath("//*[contains(@class,'mobile-play')]//img[1]/@data-src") or [""])[0]).strip() - pan_urls = [] - for node in root.xpath(site["detail_pan_xpath"]): - text = "".join(node.xpath(".//text()")).strip() - if text.startswith("http"): - pan_urls.append(text) - - return { - "vod_name": title, - "vod_pic": self._build_absolute_url(site["domains"][0], pic), - "vod_year": "", - "vod_director": self._join_next_sibling_links(root, "导演"), - "vod_actor": self._join_next_sibling_links(root, "主演"), - "vod_content": self._join_next_sibling_text(root, "剧情"), - "pan_urls": pan_urls, - "_site_name": site["name"], - } - - def _fetch_site_detail(self, site, detail_path): - html = self._request_with_failover(site, detail_path) - return self._parse_detail_page(site, detail_path, html) - - def _build_pan_lines(self, detail): - lines = [] - seen = set() - for url in detail.get("pan_urls", []): - pan_type, title = self._detect_pan_type(url) - if not pan_type or url in seen: - continue - seen.add(url) - lines.append( - ( - self.pan_priority.get(pan_type, 999), - f"{pan_type}#{detail['_site_name']}", - f"{title}${url}", - ) - ) - lines.sort(key=lambda item: item[0]) - return lines - - def detailContent(self, ids): - vod_id = ids[0] - if str(vod_id).startswith("agg:"): - payload = self._decode_aggregate_vod_id(vod_id) - details = [] - for item in payload: - site = self._get_site(item["site"]) - try: - details.append(self._fetch_site_detail(site, item["path"])) - except Exception: - continue - - primary = details[0] - all_lines = [] - seen_urls = set() - for detail in details: - for _, line_from, line_url in self._build_pan_lines(detail): - share_url = line_url.split("$", 1)[1] - if share_url in seen_urls: - continue - seen_urls.add(share_url) - all_lines.append((line_from, line_url)) - - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": primary["vod_name"], - "vod_pic": primary["vod_pic"], - "vod_year": primary["vod_year"], - "vod_director": primary["vod_director"], - "vod_actor": primary["vod_actor"], - "vod_content": primary["vod_content"], - "vod_play_from": "$$$".join([item[0] for item in all_lines]), - "vod_play_url": "$$$".join([item[1] for item in all_lines]), - } - ] - } - - info = self._decode_site_vod_id(vod_id) - site = self._get_site(info["site"]) - detail = self._fetch_site_detail(site, info["path"]) - lines = self._build_pan_lines(detail) - return { - "list": [ - { - "vod_id": vod_id, - "vod_name": detail["vod_name"], - "vod_pic": detail["vod_pic"], - "vod_year": detail["vod_year"], - "vod_director": detail["vod_director"], - "vod_actor": detail["vod_actor"], - "vod_content": detail["vod_content"], - "vod_play_from": "$$$".join([item[1] for item in lines]), - "vod_play_url": "$$$".join([item[2] for item in lines]), - } - ] - } - - def playerContent(self, flag, id, vipFlags): - pan_type, _ = self._detect_pan_type(id) - if pan_type: - return {"parse": 0, "playUrl": "", "url": id} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/玩偶聚合.txt b/py/玩偶聚合.txt new file mode 100644 index 0000000..c8c016e --- /dev/null +++ b/py/玩偶聚合.txt @@ -0,0 +1,15 @@ +// ignore +//@name:玩偶聚合 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:7B3UePi7qYy/yhpY +//@ek:base64:SUbKTR7CPhm5LyhenYs2IS0KVqdPF489fSSpZd3MioSCIr41lh2tEFhng1ih0Tq+ +//@hash:sha256:46b227015d247f3888ed7cabd794da1c840c392f5c5b19282ce9b179fadf7f87 +//@sig:base64:npHIoRgv/qH2HAgHpRCT2CDlwMw8LgdRBMxxjiNC0tOHgCCU5jACMb0lVC+u9gLYNTDHZGiSx8ospjwfOOS3AA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/瓜子.py b/py/瓜子.py deleted file mode 100755 index 7b6fef4..0000000 --- a/py/瓜子.py +++ /dev/null @@ -1,472 +0,0 @@ -# coding = utf-8 -#!/usr/bin/python -import re -import sys -import json -import time -import base64 -import hashlib -import urllib.parse -from Crypto.Cipher import AES -from Crypto.Util.Padding import pad, unpad -from Crypto.PublicKey import RSA -from Crypto.Cipher import PKCS1_v1_5 -from base.spider import Spider - -sys.path.append('..') - -class Spider(Spider): - def __init__(self): - self.name = "瓜子" - self.host = 'https://api.w32z7vtd.com' - self.token = '1be86e8e18a9fa18b2b8d5432699dad0.ac008ed650fd087bfbecf2fda9d82e9835253ef24843e6b18fcd128b10763497bcf9d53e959f5377cde038c20ccf9d17f604c9b8bb6e61041def86729b2fc7408bd241e23c213ac57f0226ee656e2bb0a583ae0e4f3bf6c6ab6c490c9a6f0d8cdfd366aacf5d83193671a8f77cd1af1ff2e9145de92ec43ec87cf4bdc563f6e919fe32861b0e93b118ec37d8035fbb3c.59dd05c5d9a8ae726528783128218f15fe6f2c0c8145eddab112b374fcfe3d79' - self.header = { - 'Cache-Control': 'no-cache', - 'Version': '2406025', - 'PackageName': 'com.uf076bf0c246.qe439f0d5e.m8aaf56b725a.ifeb647346f', - 'Ver': '1.9.2', - 'Referer': self.host, - 'Content-Type': 'application/x-www-form-urlencoded', - 'User-Agent': 'okhttp/3.12.0' - } - # 添加缓存机制 - self.cache = {} - self.cache_timeout = 300 # 5分钟缓存 - - def getName(self): - return self.name - - def danmaku(self): - return True - - def init(self, extend=''): - pass - - def homeContent(self, filter): - result = {} - classes = [ - {"type_name": "电影", "type_id": "1"}, - {"type_name": "电视剧", "type_id": "2"}, - {"type_name": "动漫", "type_id": "4"}, - {"type_name": "综艺", "type_id": "3"}, - {"type_name": "短剧", "type_id": "64"} - ] - - result['class'] = classes - - # 设置筛选条件 - 为所有分类添加筛选 - filters = {} - for cate in classes: - tid = cate['type_id'] - filters[tid] = [ - {"key": "area", "name": "地区", "value": [ - {"n": "全部", "v": "0"}, - {"n": "大陆", "v": "大陆"}, - {"n": "香港", "v": "香港"}, - {"n": "台湾", "v": "台湾"}, - {"n": "美国", "v": "美国"}, - {"n": "韩国", "v": "韩国"}, - {"n": "日本", "v": "日本"}, - {"n": "英国", "v": "英国"}, - {"n": "法国", "v": "法国"}, - {"n": "泰国", "v": "泰国"}, - {"n": "印度", "v": "印度"}, - {"n": "其他", "v": "其他"} - ]}, - {"key": "year", "name": "年份", "value": [ - {"n": "全部", "v": "0"}, - {"n": "2025", "v": "2025"}, - {"n": "2024", "v": "2024"}, - {"n": "2023", "v": "2023"}, - {"n": "2022", "v": "2022"}, - {"n": "2021", "v": "2021"}, - {"n": "2020", "v": "2020"}, - {"n": "2019", "v": "2019"}, - {"n": "2018", "v": "2018"}, - {"n": "2017", "v": "2017"}, - {"n": "2016", "v": "2016"}, - {"n": "2015", "v": "2015"}, - {"n": "2014", "v": "2014"}, - {"n": "2013", "v": "2013"}, - {"n": "2012", "v": "2012"}, - {"n": "2011", "v": "2011"}, - {"n": "2010", "v": "2010"}, - {"n": "2009", "v": "2009"}, - {"n": "2008", "v": "2008"}, - {"n": "2007", "v": "2007"}, - {"n": "2006", "v": "2006"}, - {"n": "2005", "v": "2005"}, - {"n": "更早", "v": "2004"} - ]}, - {"key": "sort", "name": "排序", "value": [ - {"n": "最新", "v": "d_id"}, - {"n": "最热", "v": "d_hits"}, - {"n": "推荐", "v": "d_score"} - ]} - ] - - result['filters'] = filters - return result - - def homeVideoContent(self): - # 首页推荐直接返回空列表，避免加载问题 - return {'list': []} - - def categoryContent(self, tid, pg, filter, extend): - videos = [] - try: - body = { - "area": extend.get('area', '0'), - "year": extend.get('year', '0'), - "pageSize": "30", - "sort": extend.get('sort', 'd_id'), - "page": str(pg), - "tid": tid - } - - cache_key = f"category_{tid}_{pg}_{hash(str(body))}" - data = self.get_cached_data(cache_key, body, '/App/IndexList/indexList') - - if data and 'list' in data: - for item in data['list']: - vod_continu = item.get('vod_continu', 0) - remarks = '电影' if vod_continu == 0 else f'更新至{vod_continu}集' - - video = { - "vod_id": f"{item.get('vod_id', '')}/{vod_continu}", - "vod_name": item.get('vod_name', ''), - "vod_pic": item.get('vod_pic', ''), - "vod_remarks": remarks - } - videos.append(video) - except Exception as e: - print(f"获取分类内容失败: {e}") - - return { - 'list': videos, - 'page': int(pg), - 'limit': 30, - 'total': 999999 - } - - def detailContent(self, ids): - try: - vod_id = ids[0].split('/')[0] - - # 获取视频详情 - t = str(int(time.time())) - body1 = { - "token_id": "1649412", - "vod_id": vod_id, - "mobile_time": t, - "token": self.token - } - qdata = self.get_data(body1, '/App/IndexPlay/playInfo') - - # 获取播放列表 - body2 = { - "vurl_cloud_id": "2", - "vod_d_id": vod_id - } - jdata = self.get_data(body2, '/App/Resource/Vurl/show') - - if not qdata or 'vodInfo' not in qdata: - return {'list': []} - - vod = qdata['vodInfo'] - - # 构建视频信息 - video_detail = { - "vod_id": vod_id, - "vod_name": vod.get('vod_name', ''), - "vod_pic": vod.get('vod_pic', ''), - "vod_year": vod.get('vod_year', ''), - "vod_area": vod.get('vod_area', ''), - "vod_actor": vod.get('vod_actor', ''), - "vod_director": vod.get('vod_director', ''), - "vod_content": vod.get('vod_use_content', '').strip(), - "vod_play_from": "嗷呜要吃瓜" - } - - # 构建播放列表 - play_list = [] - if jdata and 'list' in jdata: - for index, item in enumerate(jdata['list']): - if 'play' in item: - n = [] # 播放源名称 - p = [] # 播放参数 - for key, value in item['play'].items(): - if 'param' in value and value['param']: - n.append(key) - p.append(value['param']) - - if p: - play_name = str(index + 1) - if len(jdata['list']) == 1: - play_name = vod.get('vod_name', '') - - play_url = f"{p[-1]}||{'@'.join(n)}" - play_list.append(f"{play_name}${play_url}") - - video_detail["vod_play_url"] = "#".join(play_list) - - return {'list': [video_detail]} - - except Exception as e: - print(f"获取详情失败: {e}") - return {'list': []} - - def searchContent(self, key, quick, pg=1): - videos = [] - try: - body = { - "keywords": key, - "order_val": "1", - "page": str(pg) - } - - # 搜索不使用缓存，确保实时性 - start_time = time.time() - data = self.get_data(body, '/App/Index/findMoreVod', use_cache=False) - end_time = time.time() - - print(f"搜索请求耗时: {end_time - start_time:.2f}秒") - - if data and 'list' in data: - for item in data['list']: - vod_continu = item.get('vod_continu', 0) - remarks = '电影' if vod_continu == 0 else f'更新至{vod_continu}集' - - video = { - "vod_id": f"{item.get('vod_id', '')}/{vod_continu}", - "vod_name": item.get('vod_name', ''), - "vod_pic": item.get('vod_pic', ''), - "vod_remarks": remarks - } - videos.append(video) - except Exception as e: - print(f"搜索失败: {e}") - - return { - 'list': videos, - 'page': int(pg), - 'limit': 30, - 'total': 999999 - } - - def playerContent(self, flag, id, vipFlags): - try: - # 解析播放信息 - parts = id.split('||') - if len(parts) < 2: - return {"parse": 0, "playUrl": "", "url": ""} - - param_str = parts[0] - resolutions = parts[1].split('@') if len(parts) > 1 else [] - - # 解析参数 - params = {} - for pair in param_str.split('&'): - if '=' in pair: - key, value = pair.split('=', 1) - params[key] = value - - # 获取播放链接 - if resolutions: - # 分辨率从大到小排序 - resolutions.sort(key=lambda x: int(x) if x.isdigit() else 0, reverse=True) - - # 使用最大分辨率 - params['resolution'] = resolutions[0] - body = params - - start_time = time.time() - data = self.get_data(body, '/App/Resource/VurlDetail/showOne', use_cache=False) - end_time = time.time() - print(f"播放链接获取耗时: {end_time - start_time:.2f}秒") - - if data and 'url' in data: - return { - "parse": 0, - "playUrl": "", - "url": data['url'], - "header": json.dumps(self.header) - } - - return {"parse": 0, "playUrl": "", "url": ""} - - except Exception as e: - print(f"播放解析失败: {e}") - return {"parse": 0, "playUrl": "", "url": ""} - - def isVideoFormat(self, url): - video_formats = ['.m3u8', '.mp4', '.avi', '.mkv', '.flv', '.ts'] - return any(url.lower().endswith(fmt) for fmt in video_formats) - - def manualVideoCheck(self): - pass - - def localProxy(self, params): - return None - - def aes_encrypt(self, text, key, iv): - """AES加密""" - try: - key_bytes = key.encode('utf-8') - iv_bytes = iv.encode('utf-8') - cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes) - encrypted = cipher.encrypt(pad(text.encode('utf-8'), AES.block_size)) - return encrypted.hex().upper() - except Exception as e: - print(f"AES加密失败: {e}") - return "" - - def aes_decrypt(self, text, key, iv): - """AES解密""" - try: - key_bytes = key.encode('utf-8') - iv_bytes = iv.encode('utf-8') - cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes) - encrypted_bytes = bytes.fromhex(text) - decrypted = unpad(cipher.decrypt(encrypted_bytes), AES.block_size) - return decrypted.decode('utf-8') - except Exception as e: - print(f"AES解密失败: {e}") - return "" - - def rsa_decrypt(self, encrypted_data, private_key): - """RSA解密""" - try: - # 解码base64数据 - encrypted_bytes = base64.b64decode(encrypted_data) - - # 导入私钥 - rsa_key = RSA.import_key(private_key) - cipher = PKCS1_v1_5.new(rsa_key) - - # 解密 - decrypted = cipher.decrypt(encrypted_bytes, None) - return decrypted.decode('utf-8') if decrypted else "" - except Exception as e: - print(f"RSA解密失败: {e}") - return "" - - def get_cached_data(self, cache_key, data, path): - """带缓存的数据获取""" - current_time = time.time() - if cache_key in self.cache: - cached_data, timestamp = self.cache[cache_key] - if current_time - timestamp < self.cache_timeout: - return cached_data - - # 缓存不存在或已过期，重新获取 - result = self.get_data(data, path) - if result: - self.cache[cache_key] = (result, current_time) - return result - - def get_data(self, data, path, use_cache=True): - """获取数据的主要方法""" - try: - # 构建缓存键 - cache_key = f"{path}_{hash(str(data))}" if use_cache else None - - if use_cache and cache_key in self.cache: - cached_data, timestamp = self.cache[cache_key] - if time.time() - timestamp < self.cache_timeout: - return cached_data - - start_time = time.time() - - # AES加密请求数据 - request_key = self.aes_encrypt(json.dumps(data), 'mvXBSW7ekreItNsT', '2U3IrJL8szAKp0Fj') - if not request_key: - return None - - # 生成签名 - t = str(int(time.time())) - keys = "Qmxi5ciWXbQzkr7o+SUNiUuQxQEf8/AVyUWY4T/BGhcXBIUz4nOyHBGf9A4KbM0iKF3yp9M7WAY0rrs5PzdTAOB45plcS2zZ0wUibcXuGJ29VVGRWKGwE9zu2vLwhfgjTaaDpXo4rby+7GxXTktzJmxvneOUdYeHi+PZsThlvPI=" - sign_str = f"token_id=,token={self.token},phone_type=1,request_key={request_key},app_id=1,time={t},keys={keys}*&zvdvdvddbfikkkumtmdwqppp?|4Y!s!2br" - signature = hashlib.md5(sign_str.encode()).hexdigest() - - # 构建请求体 - body = { - 'token': self.token, - 'token_id': '', - 'phone_type': '1', - 'time': t, - 'phone_model': 'xiaomi-22021211rc', - 'keys': keys, - 'request_key': request_key, - 'signature': signature, - 'app_id': '1', - 'ad_version': '1' - } - - # 发送请求 - 设置超时时间 - url = f"{self.host}{path}" - response = self.post(url, headers=self.header, data=body, timeout=10) - - if response.status_code != 200: - print(f"API请求失败: {response.status_code}, 路径: {path}") - return None - - response_data = response.json() - if 'data' not in response_data: - print(f"API返回数据格式错误, 路径: {path}") - return None - - data_response = response_data['data'] - - # RSA解密响应密钥 - private_key = """-----BEGIN PRIVATE KEY----- -MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGAe6hKrWLi1zQmjTT1 -ozbE4QdFeJGNxubxld6GrFGximxfMsMB6BpJhpcTouAqywAFppiKetUBBbXwYsYU -1wNr648XVmPmCMCy4rY8vdliFnbMUj086DU6Z+/oXBdWU3/b1G0DN3E9wULRSwcK -ZT3wj/cCI1vsCm3gj2R5SqkA9Y0CAwEAAQKBgAJH+4CxV0/zBVcLiBCHvSANm0l7 -HetybTh/j2p0Y1sTXro4ALwAaCTUeqdBjWiLSo9lNwDHFyq8zX90+gNxa7c5EqcW -V9FmlVXr8VhfBzcZo1nXeNdXFT7tQ2yah/odtdcx+vRMSGJd1t/5k5bDd9wAvYdI -DblMAg+wiKKZ5KcdAkEA1cCakEN4NexkF5tHPRrR6XOY/XHfkqXxEhMqmNbB9U34 -saTJnLWIHC8IXys6Qmzz30TtzCjuOqKRRy+FMM4TdwJBAJQZFPjsGC+RqcG5UvVM -iMPhnwe/bXEehShK86yJK/g/UiKrO87h3aEu5gcJqBygTq3BBBoH2md3pr/W+hUM -WBsCQQChfhTIrdDinKi6lRxrdBnn0Ohjg2cwuqK5zzU9p/N+S9x7Ck8wUI53DKm8 -jUJE8WAG7WLj/oCOWEh+ic6NIwTdAkEAj0X8nhx6AXsgCYRql1klbqtVmL8+95KZ -K7PnLWG/IfjQUy3pPGoSaZ7fdquG8bq8oyf5+dzjE/oTXcByS+6XRQJAP/5ciy1b -L3NhUhsaOVy55MHXnPjdcTX0FaLi+ybXZIfIQ2P4rb19mVq1feMbCXhz+L1rG8oa -t5lYKfpe8k83ZA== ------END PRIVATE KEY-----""" - - bodyki_json = self.rsa_decrypt(data_response['keys'], private_key) - if not bodyki_json: - print("RSA解密失败") - return None - - bodyki = json.loads(bodyki_json) - - # AES解密响应数据 - decrypted_data = self.aes_decrypt(data_response['response_key'], bodyki['key'], bodyki['iv']) - if not decrypted_data: - print("AES解密失败") - return None - - result = json.loads(decrypted_data) - - end_time = time.time() - print(f"数据获取耗时: {end_time - start_time:.2f}秒, 路径: {path}") - - # 缓存结果 - if use_cache and cache_key: - self.cache[cache_key] = (result, time.time()) - - return result - - except Exception as e: - print(f"获取数据失败: {e}, 路径: {path}") - return None - - def get_md5(self, text): - """计算MD5""" - return hashlib.md5(text.encode()).hexdigest() - -if __name__ == '__main__': - pass diff --git a/py/瓜子.txt b/py/瓜子.txt new file mode 100644 index 0000000..953e82c --- /dev/null +++ b/py/瓜子.txt @@ -0,0 +1,15 @@ +// ignore +//@name:瓜子 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:8eyGlYLrxW45ePeq +//@ek:base64:XMU+zN3g9FgcnTjjDBU2NOiNNVBMu71weyb50E6v0Y/L9XORkuIWpbtXs8OqLe/q +//@hash:sha256:919d8533885308b0abfaf614103638278135f3605e88e4b8440d1d474d5d3eeb +//@sig:base64:WPrWERvLaYAJkG8grWox6VZ0sWPwK5BHXuM3HUZhwuOHEFI9gcsUvJ0Yut6C4lIV0/p6XuwBbf+tYypJg9a2Bg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/盘聚.txt b/py/盘聚.txt index ff8c3ea..ad7304d 100644 --- a/py/盘聚.txt +++ b/py/盘聚.txt @@ -7,9 +7,9 @@ //@wrap:hkdf-aes-keywrap //@sign:ed25519 //@kid:k2026_04 -//@nonce:base64:kPT/Qsj1x6S69M2v -//@ek:base64:x73LJU4nRXAyvE88kr/IJdio4iqyskkxxIasfP1S7wsfs+C4qvAH4VIbFuXp7Byy -//@hash:sha256:15842532aafe3021a69d757450ad8a61dab6e3a36df564918585d8272a0b97a4 -//@sig:base64:vU0FpWG58Xtc4BowvK5ms7OHcumL8uJehiTMFSaioDZc/20f5+NTFxDYn6KCyQDLrG/JJI7prk1mvlouuI4KAQ== +//@nonce:base64:CNf6zbCyYAu6T8jV +//@ek:base64:lkTJQPHC2uEGkQ4b92FwbE+Bq+Ys2WvZySMaw2mz7LETlXVXdjXgocFEaO5lzBuC +//@hash:sha256:b1b95d2c34692757310a3f805afad4ec98137aeb5713c27279f2ab88c376cf0e +//@sig:base64:T3Eg2Qpqct6ssLxTb6w4xmlx3pm5P17GmcbvifCvVw8T5CSkU3/P5TNwucmzGbNoQ9xuTkQEHCBf0Kk72DTrCw== // ignore -payload.base64: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 \ No newline at end of file +payload.base64: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 \ No newline at end of file diff --git a/py/短剧优选.txt b/py/短剧优选.txt index 6c271d5..6ffa185 100644 --- a/py/短剧优选.txt +++ b/py/短剧优选.txt @@ -7,9 +7,9 @@ //@wrap:hkdf-aes-keywrap //@sign:ed25519 //@kid:k2026_04 -//@nonce:base64:TZDSOqLqAh3ZXuAj -//@ek:base64:nNOw4moWpyvgrRxS7Es60drpuhDUuedETQmLW+FuhoKbRHs/n2frKqcv07qi+9IX +//@nonce:base64:BkCxYxAcrGnIE75g +//@ek:base64:Mw4jF48Z4KX5Ou8Wkr4VjIgFwPwTM2n/zC66XPhPgBqmouQz+2FAX7dMOXU6+ZVf //@hash:sha256:52a0be97defdab31e189edfe8e81fa3d17a1510ad36920983f6ea06bf37d8d4e -//@sig:base64:6noinMbxWrmmFURttb6o/GtM4SgpuAkLbdaN4mYeDaksQ6NGnEGynQ0mhFA2wy5K3LYblokOMOcqVUZD9cc9Dg== +//@sig:base64:vQoXkpRB+ao1z874gntQHTTQHjo1TPB3cb56qL9eUtGbBtwnS55JelO5W7dh37HY1x8Zhd6ciKEKURakmV7LAA== // ignore -payload.base64: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 \ No newline at end of file +payload.base64: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 \ No newline at end of file diff --git a/py/短剧网.py b/py/短剧网.py deleted file mode 100644 index 5eed18c..0000000 --- a/py/短剧网.py +++ /dev/null @@ -1,238 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "短剧网" - self.host = "https://sm3.cc" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) " - "AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "1", "type_name": "短剧大全"}, - {"type_id": "2", "type_name": "更新短剧"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - return {"list": []} - - def _stringify(self, value): - return "" if value is None else str(value) - - def _build_url(self, path): - raw = self._stringify(path).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - if raw.startswith("/"): - return self.host + raw - return self.host + "/" + raw - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10, verify=False) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for card in root.xpath("//li[contains(@class,'col-6')]"): - anchors = card.xpath(".//h3[contains(@class,'f-14')]//a[@href]") - if not anchors: - continue - anchor = anchors[0] - name = self._clean_text("".join(anchor.xpath(".//text()"))) - href = self._stringify((anchor.xpath("./@href") or [""])[0]).strip() - title_attr = self._stringify((anchor.xpath("./@title") or [""])[0]).strip() - if not name or not href: - continue - url = self._build_url(href) - if url in seen: - continue - seen.add(url) - pic = self._build_url( - (card.xpath(".//img[contains(@class,'lazy')]/@data-original") or [""])[0] - ) - remarks = "" - if title_attr: - m = re.search(r"（(.+?)）", title_attr) - if m: - remarks = m.group(1) - items.append( - { - "vod_id": url, - "vod_name": name, - "vod_pic": pic, - "vod_remarks": remarks, - } - ) - return items - - def _page_result(self, items, pg): - page = int(pg) - return { - "list": items, - "page": page, - "pagecount": page + 1 if items else page, - "limit": len(items) or 20, - "total": (page + 1 if items else page) * (len(items) or 20), - } - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - url = f"{self.host}/?cate={tid}&page={page}" - items = self._parse_cards(self._request_html(url)) - return self._page_result(items, pg) - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return self._page_result([], pg) - url = f"{self.host}/search.php?q={quote(keyword)}&page={page}" - items = self._parse_cards(self._request_html(url)) - return self._page_result(items, pg) - - def _is_netdisk_url(self, value): - text = self._stringify(value).strip().lower() - return any( - token in text - for token in [ - "drive.uc.cn", - "pan.quark.cn", - "pan.baidu.com", - "pan.xunlei.com", - "alipan.com", - "aliyundrive.com", - ] - ) - - def _normalize_disk_name_from_url(self, value): - text = self._stringify(value).strip().lower() - if "pan.baidu.com" in text: - return "baidu" - if "pan.quark.cn" in text: - return "quark" - if "drive.uc.cn" in text: - return "uc" - if "alipan.com" in text or "aliyundrive.com" in text: - return "aliyun" - if "pan.xunlei.com" in text: - return "xunlei" - return "" - - def _disk_priority(self, name): - order = {"baidu": 1, "quark": 2, "uc": 3, "aliyun": 4, "xunlei": 5} - return order.get(name, 999) - - def _extract_share_links(self, html): - root = self.html(html) - if root is None: - return [] - links = [] - seen = set() - for anchor in root.xpath("//*[contains(@class,'content')]//a[@href]"): - href = self._build_url((anchor.xpath("./@href") or [""])[0]) - if not href or href in seen: - continue - seen.add(href) - links.append(href) - return links - - def _build_play_from_links(self, share_links): - if not share_links: - return {"vod_play_from": "短剧网", "vod_play_url": ""} - grouped = {} - order_seen = [] - for link in share_links: - disk_name = self._normalize_disk_name_from_url(link) - if not disk_name: - continue - if disk_name not in grouped: - grouped[disk_name] = [] - order_seen.append(disk_name) - title = disk_name - urls_in_group = {item.split("$", 1)[1] for item in grouped[disk_name]} - if link not in urls_in_group: - grouped[disk_name].append(f"{title}${link}") - if not grouped: - fallback = "#".join( - f"{i + 1}$push://{url}" for i, url in enumerate(share_links) - ) - return {"vod_play_from": "短剧网", "vod_play_url": fallback} - names = sorted(order_seen, key=self._disk_priority) - return { - "vod_play_from": "$$$".join(names), - "vod_play_url": "$$$".join("#".join(grouped[n]) for n in names), - } - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - url = self._build_url(raw_id) - if not url: - continue - html = self._request_html(url) - root = self.html(html) - if root is None: - continue - title = self._clean_text("".join(root.xpath("//h1[1]//text()"))) - if not title: - title_text = self._clean_text("".join(root.xpath("//title[1]//text()"))) - title = title_text.split("(")[0].strip() or "短剧" - pic = self._build_url( - (root.xpath("(//img[contains(@class,'lazy')]/@data-original)[1]") or [""])[0] - or (root.xpath("(//img/@src)[1]") or [""])[0] - ) - share_links = self._extract_share_links(html) - play_data = self._build_play_from_links(share_links) - result["list"].append( - { - "vod_id": url, - "vod_name": title, - "vod_pic": pic, - "vod_content": "此为推送网盘规则", - "vod_play_from": play_data["vod_play_from"], - "vod_play_url": play_data["vod_play_url"], - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - raw = self._stringify(id).strip() - if raw.startswith("push://"): - return {"parse": 0, "url": raw[7:]} - if self._is_netdisk_url(raw): - return {"parse": 0, "url": raw} - return {"parse": 0, "url": raw} diff --git a/py/短剧网.txt b/py/短剧网.txt new file mode 100644 index 0000000..71cc913 --- /dev/null +++ b/py/短剧网.txt @@ -0,0 +1,15 @@ +// ignore +//@name:短剧网 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:hPIjJYGztwaU2muh +//@ek:base64:7e1gb7voUZKiekVRUxnUkc/EnfbFpI8/XMIhoZhVVCjy4jUgcsD4BudIAVKePTim +//@hash:sha256:c03d7523a3de38d7c4ffd14cae5cfe15caf084b469f0c57fe6c9bbb047bbbb95 +//@sig:base64:WmBXhmbHghxumGOcRIcVJi/9GwgJD48IBLKk6amxLGxrg7oCWIMfqzBs1YDWfxBpYZRPyzKGcosiA/ftQXs9CQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/糯米.txt b/py/糯米.txt index eec6221..2e05cc8 100644 --- a/py/糯米.txt +++ b/py/糯米.txt @@ -7,9 +7,9 @@ //@wrap:hkdf-aes-keywrap //@sign:ed25519 //@kid:k2026_04 -//@nonce:base64:DLzuLyG3kAa9MbMZ -//@ek:base64:JZCh3uylLat7TmXI7b4B5wZtQZolBotAUHoniBrrVX/Jp2GJe4i7nzP3wJW9zmNt +//@nonce:base64:PFjDv49hrIJtyWmt +//@ek:base64:ANOCfDcZz6xDnclIY/4+QJraJ0SaUyN3/QzyVDkNhQZQN7wd3s2Bgp88uxyx73za //@hash:sha256:700cdbffeba6ed07f816a2890612f0c12d3768aed2a65c8d05ddc8e9918bbc70 -//@sig:base64:0UJ7D3JZCaztY3ILnUdT/LDFXL9qDKibWkEffVbK/A8QLOlWNOHJelQKCsIAH6Q1FXukN01eSsOC6fgK8GG/DQ== +//@sig:base64:wJLJH5w7VB8lo3qVXnJtRA2a6ruw8/5xWEMS7ZS5FzyOQw3kNAD1WHXJVXpAShuFsZ0NPMuIQd0bQaXN9bfCAg== // ignore -payload.base64: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 \ No newline at end of file +payload.base64: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 \ No newline at end of file diff --git a/py/红果短剧.txt b/py/红果短剧.txt index 60ed90c..b31ea1a 100644 --- a/py/红果短剧.txt +++ b/py/红果短剧.txt @@ -7,9 +7,9 @@ //@wrap:hkdf-aes-keywrap //@sign:ed25519 //@kid:k2026_04 -//@nonce:base64:3yMG/lP1rbyiuq2u -//@ek:base64:+KBsZiOu5xvmWi8uouBxrTm6kxabuwL4NGTFM/130SPS/5D9g9nDCYcEFDECR+EB +//@nonce:base64:T9PLc/fGozlz4aNa +//@ek:base64:MPkNCEw9sYQjZZdqyYcENwmapavmgHjUe3MFLgvVx3xHIJ26a3j5F4BJnGQ5G+x9 //@hash:sha256:656890e9a95c07003623fc29165860798021bcb22330a9506c2570eda26e7b6a -//@sig:base64:p8EDrbE4DwaXS/DDPe206MP3x/vZkYCSV+TtioaMZcsArumBwzeTT5A+OFbJUp0pfJ59mWC/I5phwESRtntLDA== +//@sig:base64:+kOlFQSCjZ6pxf/4kCPecvGRDMIjcG12jvvsJimhqwnOBJFHZgjV6gd3Z1mweSNBuU6CY9tp/RH+zdDMcx3BDw== // ignore -payload.base64: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 \ No newline at end of file +payload.base64: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 \ No newline at end of file diff --git a/py/耐视点播.py b/py/耐视点播.py deleted file mode 100644 index 07bb20e..0000000 --- a/py/耐视点播.py +++ /dev/null @@ -1,353 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "耐视点播" - self.host = "https://nsvod.me" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/120.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "连续剧"}, - {"type_id": "3", "type_name": "综艺"}, - {"type_id": "4", "type_name": "动漫"}, - {"type_id": "37", "type_name": "Netflix"}, - {"type_id": "40", "type_name": "纪录片"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes} - - def _stringify(self, value): - return "" if value is None else str(value) - - def _clean_text(self, text): - raw = self._stringify(text).replace(" ", " ") - raw = re.sub(r"<[^>]+>", " ", raw) - return re.sub(r"\s+", " ", raw).strip() - - def _build_url(self, path): - raw = self._stringify(path).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw) - - def _extract_vod_id(self, href): - matched = re.search(r"/index\.php/vod/detail/id/(\d+)\.html", self._stringify(href)) - return matched.group(1) if matched else "" - - def _build_detail_url(self, vod_id): - return self._build_url(f"/index.php/vod/detail/id/{self._stringify(vod_id).strip()}.html") - - def _request_html(self, path_or_url, headers=None, referer=None): - target = path_or_url if self._stringify(path_or_url).startswith("http") else self._build_url(path_or_url) - merged_headers = dict(self.headers) - if headers: - merged_headers.update(headers) - merged_headers["Referer"] = referer or self.headers["Referer"] - response = self.fetch(target, headers=merged_headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_cards(self, html): - items = [] - seen = set() - for block, href, vod_id, title in re.findall( - r'(<a[^>]*href="(/index\.php/vod/detail/id/(\d+)\.html)"[^>]*title="([^"]*)"[^>]*>[\s\S]*?</a>)', - self._stringify(html), - re.I, - ): - if vod_id in seen or not title: - continue - seen.add(vod_id) - pic_match = re.search(r'data-src="([^"]*)"', block, re.I) or re.search(r'src="([^"]*)"', block, re.I) - remarks_match = re.search(r'public-list-prb[^>]*>([^<]*)</span>', block, re.I) - if not remarks_match: - remarks_match = re.search(r'public-list-subtitle[^>]*>([^<]*)</div>', block, re.I) - items.append( - { - "vod_id": vod_id, - "vod_name": title.strip(), - "vod_pic": self._build_url(pic_match.group(1) if pic_match else ""), - "vod_remarks": self._clean_text(remarks_match.group(1) if remarks_match else ""), - } - ) - return items - - def homeVideoContent(self): - return {"list": self._parse_cards(self._request_html(self.host + "/"))} - - def _extract_section_cards(self, html, tid): - section_map = { - "1": "最新电影", - "2": "最新连续剧", - "3": "最新综艺", - "4": "最新动漫", - "37": "最新Netflix", - "40": "最新纪录片", - } - section_name = section_map.get(self._stringify(tid)) - if not section_name: - return [] - markers = [ - "最新热播", - "最新Netflix", - "最新电影", - "最新连续剧", - "最新资讯", - "最新动漫", - "最新综艺", - "最新纪录片", - ] - body = self._stringify(html) - start_tag = f'title-h cor4">{section_name}' - start = body.find(start_tag) - if start < 0: - return [] - end = len(body) - for name in markers: - if name == section_name: - continue - pos = body.find(f'title-h cor4">{name}', start + len(start_tag)) - if pos > 0 and pos < end: - end = pos - return self._parse_cards(body[start:end]) - - def _parse_search_cards(self, html): - items = [] - seen = set() - for block in re.findall( - r'(<div[^>]*class="[^"]*module-search-item[^"]*"[^>]*>[\s\S]*?</div>)', - self._stringify(html), - re.I, - ): - href_match = re.search(r'class="[^"]*video-serial[^"]*"[^>]*href="([^"]*)"', block, re.I) - title_match = re.search(r'class="[^"]*video-serial[^"]*"[^>]*title="([^"]*)"', block, re.I) - pic_match = re.search(r'data-src="([^"]*)"', block, re.I) or re.search(r'src="([^"]*)"', block, re.I) - remark_match = re.search(r'class="[^"]*video-serial[^"]*"[^>]*>([^<]*)</a>', block, re.I) - vod_id = self._extract_vod_id(href_match.group(1) if href_match else "") - if not vod_id or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": self._clean_text(title_match.group(1) if title_match else ""), - "vod_pic": self._build_url(pic_match.group(1) if pic_match else ""), - "vod_remarks": self._clean_text(remark_match.group(1) if remark_match else ""), - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - url = self._build_url(f"/index.php/vod/show/id/{tid}.html?page={page}") - items = self._parse_cards(self._request_html(url)) - if not items: - items = self._extract_section_cards(self._request_html(self.host + "/"), tid) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - url = self._build_url(f"/index.php/vod/search.html?wd={quote(keyword)}") - items = self._parse_search_cards(self._request_html(url)) - return {"page": page, "total": len(items), "list": items} - - def _strip_title(self, title): - matched = re.search(r"《([^》]+)》", self._stringify(title)) - if matched: - return matched.group(1) - return self._clean_text(title) - - def _parse_play_groups(self, html): - source_names = [] - for raw in re.findall(r'<div[^>]*class="[^"]*swiper-slide[^"]*"[^>]*>([\s\S]*?)</div>', self._stringify(html), re.I): - cleaned = re.sub(r"\d+\s*集?$", "", self._clean_text(raw)).strip() - if cleaned: - source_names.append(cleaned) - - groups = [] - for index, block in enumerate( - re.findall(r'(<div[^>]*class="[^"]*anthology-list-box[^"]*"[^>]*>[\s\S]*?</div>)', self._stringify(html), re.I) - ): - episodes = [] - for href, title in re.findall(r'<a[^>]*href="([^"]*/index\.php/vod/play/[^"]*)"[^>]*>([\s\S]*?)</a>', block, re.I): - episodes.append(f"{self._clean_text(title)}${href.replace('&', '&').strip()}") - if episodes: - groups.append((source_names[index] if index < len(source_names) else f"线路{index + 1}", "#".join(episodes))) - - if not groups: - episodes = [] - for href, title in re.findall( - r'<a[^>]*href="([^"]*/index\.php/vod/play/[^"]*)"[^>]*>([\s\S]*?)</a>', - self._stringify(html), - re.I, - ): - episodes.append(f"{self._clean_text(title)}${href.replace('&', '&').strip()}") - if episodes: - groups.append(("线路1", "#".join(episodes))) - return groups - - def _parse_detail_page(self, vod_id, html): - body = self._stringify(html) - name_match = re.search(r"<title>([^<]+)", body, re.I) - name = self._strip_title(name_match.group(1) if name_match else "") - if not name: - slide_match = re.search(r'slide-info-title[^>]*>([^<]+)<', body, re.I) - name = self._clean_text(slide_match.group(1) if slide_match else "") - - pic_match = re.search(r'detail-pic[\s\S]*?data-src="([^"]*)"', body, re.I) or re.search( - r'detail-pic[\s\S]*?src="([^"]*)"', - body, - re.I, - ) - year_match = re.search(r"年份[\s\S]*?(\d{4})", body, re.I) or re.search(r"年份[\s\S]*?(\d{4})", body, re.I) - area_match = re.search(r"地区[\s\S]*?([^<]+)", body, re.I) - director_match = re.search(r"导演\s*([^<\n]+)", body, re.I) - actor_match = re.search(r"主演\s*([^<\n]+)", body, re.I) - content_match = re.search(r'id="height_limit"[^>]*>([\s\S]*?)
', body, re.I) - groups = self._parse_play_groups(body) - - director = self._clean_text(director_match.group(1) if director_match else "") - actor = self._clean_text(actor_match.group(1) if actor_match else "") - return { - "vod_id": self._stringify(vod_id), - "vod_name": name, - "vod_pic": self._build_url(pic_match.group(1) if pic_match else ""), - "vod_year": year_match.group(1) if year_match else "", - "vod_area": self._clean_text(area_match.group(1) if area_match else ""), - "vod_director": "" if director == "未知" else director, - "vod_actor": "" if actor == "未知" else actor, - "vod_content": self._clean_text(content_match.group(1) if content_match else "") or "暂无简介", - "vod_play_from": "$$$".join(item[0] for item in groups), - "vod_play_url": "$$$".join(item[1] for item in groups), - } - - def detailContent(self, ids): - vod_id = self._stringify(ids[0] if isinstance(ids, list) and ids else ids).strip() - if not vod_id: - return {"list": []} - vod = self._parse_detail_page(vod_id, self._request_html(self._build_detail_url(vod_id))) - if not vod.get("vod_play_from"): - return {"list": []} - return {"list": [vod]} - - def _extract_balanced_object(self, text, start_index): - raw = self._stringify(text) - if start_index < 0 or start_index >= len(raw) or raw[start_index] != "{": - return "" - - depth = 0 - in_string = False - quote_char = "" - escaped = False - - for index in range(start_index, len(raw)): - char = raw[index] - if in_string: - if escaped: - escaped = False - elif char == "\\": - escaped = True - elif char == quote_char: - in_string = False - continue - - if char in ('"', "'"): - in_string = True - quote_char = char - continue - - if char == "{": - depth += 1 - continue - - if char == "}": - depth -= 1 - if depth == 0: - return raw[start_index : index + 1] - - return "" - - def _extract_player_data(self, html): - text = self._stringify(html) - matched = re.search(r"player_aaaa\s*=", text, re.I) - if not matched: - return {} - object_start = text.find("{", matched.end()) - if object_start < 0: - return {} - raw_object = self._extract_balanced_object(text, object_start) - if not raw_object: - return {} - try: - return json.loads(raw_object) - except Exception: - return {} - - def _pick_direct_media_url(self, html): - matched = re.search(r'(https?://[^"\'\s]+\.m3u8[^"\'\s]*)', self._stringify(html), re.I) - return matched.group(1) if matched else "" - - def playerContent(self, flag, id, vipFlags): - play_url = self._build_url(id) - html = self._request_html(play_url, headers={"User-Agent": self.headers["User-Agent"]}, referer=self.host + "/") - player_data = self._extract_player_data(html) - if player_data.get("url"): - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": self._stringify(player_data.get("url")), - "header": {"User-Agent": self.headers["User-Agent"], "Referer": play_url}, - } - - media_url = self._pick_direct_media_url(html) - if media_url: - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": media_url, - "header": {"User-Agent": self.headers["User-Agent"], "Referer": play_url}, - } - - return { - "parse": 0, - "jx": 1, - "playUrl": "", - "url": play_url, - "header": dict(self.headers), - } diff --git a/py/耐视点播.txt b/py/耐视点播.txt new file mode 100644 index 0000000..4b531b8 --- /dev/null +++ b/py/耐视点播.txt @@ -0,0 +1,15 @@ +// ignore +//@name:耐视点播 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:crfFIbirDUkdx000 +//@ek:base64:1JHogLPb0EF92tP8oZikkJH91Zu5bhLlr36NovDFvYbuWT9AeDHGhGWblJqma5oL +//@hash:sha256:8e207cdaf89ee34a963d3a98b63a830af43e72bddc9b03753c3ba3a4a7eead8f +//@sig:base64:qa4dkIo+pq4Qm+EkPhzbjdNFZh0q1PqYRXCxnK9A2w0sk669KdPhFXOLTY1Eh6+fJkV+p3cPrxnPp3ZsfYsBDg== +// ignore +payload.base64:a/BQRb+IZsdLGVsM5uJGgoIJH5MqtyBQiVT4jQ5V9J6nNM6ToobuQES4mh8lqc31qaDmmrhgOBFW5jmFFxIIKj7iRjL+I+KXkQfjoqGiuCDskJo3S5tOIPJPry45ULnneLP9AglM6VeDBgq+9UDK/7j0xwghrJGVb17Qy0DS5Uy7ZQRjzLhUCMhcqVHcmxK0VrmcJLC8zyQsF2Lfing2yBFzND3YOp+FJLbtCUs7EiH4VMobAeTzVNt7cW6vBc6nUgwNTcXCNkW9rr5peKlAfAh/oIsQuUbMqwbeY8wrXBGR34F2cRLhNluICXfckrmCwhQee1yvv8kxFzEbxBXlL9/gNe9P+byrWrT1ZqMmmdUOnpyFKyW6/EdCrwowq5JiC7kvdoGywc3HNWUFurZgYfmwqKsFGDedzzBljSaf4Luk7UZ4gG4imAkSFypD23ODJtUUB0+w8Yhc0a7hBBOOrRVlVJ72zbipPsNJQ+9FtNtfW4GxOOVY6T58njRMTAMOFldmxTCfvOjIvXq3wtShDMhlysb6Nus3vk6Kf56Kwpd3m9mr7cpNITnfg14ll16bmMMvwFQNUDbiHmoiBJEHnlrcxbob33vnCyEOrFj5F0xhJ0gTQ+sRplHcFp93/5VF72qB3iox24rCsL6JA9zN6VHBYuC/3vbForJZ3tVK3dFJw77CAyNCRICAkRYfe9uGlhVHLG4ZjzDHIzPWiVTmEqjmrSiO5Rtxivj3AlO0RP7lw51QI1x0k74FWohp6k4Sbzg/DuyzA3JqbpKj7lUvt29ta2y6fhnUsKZ0/LfNSbskqZOoE0jZOvlg+zjsP8eFYFqhHWD+zS254cqr42FwX9AcrMROE+cWmEW/k6uWb6i8BzGqDSqPlZkjlpT2YgIgS6pdHAJt81c/YTgjnPOM0Paeo8chSqE9VjuuQ48yRbdxEYeRabARaDWlIu/JyekRCRWRpggAMqqBt5XyRlpIScGUtX7WvLswuOVZhofupkDML++/8OCk37RepYdJG4kQSpNqVPE7qbuSUDkuEQKxXvFGlJwrX7Z5SHyw0mGftep/9nMZpYVmlkaSpZ/C7FoBVsZ5Mk28JwlCMPKqxZvWblrDTCldtV7+ZumEsjeOMrOGVjRL87HpDpDNRfM81iixze6ywnxo89uYbSatr3+XVZb28Tq1Jgxnz1o19jFXCYoz1SZly2R2XPag32ndM9Zc4C99bAljeB86jUVg+FiKj92onQ4Zk3D5ughyLG+jwZTQn5Ab11aSDyaCY2zVke97s8TSR9uD3n4a2wVrA/UnwVl5sjpCbgwJCKoydlsKWxOQJkr+EFKcJyrihvmfD/ZWNV/LHkRJnDibMUInjk9Oh7sweDyvwFY7JQzwh9b6YXZMN0HKCa0CFxPGkRVxPXFAUpDKRvoIEmwwAOo4hNyvZXbLnhocsdJLrUt6RUIFSYZ7fq8P2GxNFgAl4jQrtBGf646DobEvBBLrTfPZ88TLDAk2HAFaee4okmzsUE2dBjYhAyzA1/qcVBO7KTU2ojZEnzfKeNNd+2ks01aByMJkwyNM6ylhV5uCTMW6sVowR2ssUfy2yrPC/yd/FEUv2bXclhkDwmRVtcUremgx2/vJzig+yIR0UsQMvmcdnHukRKRCpwED0Atg2c4RfcUlqvUpj1JOJKXC+8noyqI5MeMhvU5eEsi7FV19BR/SzhkRMcpIcNaLJvNRRYf8AzFA6Y6ZJi2OSR9tQ/Gk22/nXiZvZ8kQ9079FmGFCW3fwOCK51WkHcDEcbIjmLFvGLIMdch7gWqfJKpJQrDQ6tvTlq4uJjq3/XGcl2n0BBcUGIQAd4LOz/kfpooiD9L7dMysoRtbpcvk2dXhY0TcSe90xt5RL56KWjbNJ9DEJxcGYApzEWWh/7ZLVut96DHM5X9T54iaiF+mh9IQ8E9au7KEOd0PvFaQITaHiwDOIo3lWVwM7NgfdUkWfyboaFNK14zIhw7gfMe5Ze/WXf3ueX63hJA2Jor+Z901ZQx2lm9WYd2RIsH9Zu3+bVLaU2aeEZmJN9SD0JDn1b2np0TIgP/v9zQxRT7Z1duOUdHWX2Eui8U3uEXfk+6tHZvr9Y6iI9RMqgXGoQwaBq6+7xEZHrAMptwB43tqnUklXEGlcwLlQrQZIp6O7sf/f0BpM15ST//4XUTcSrdFcZSM8a8XK1POwAUoHRj4bM+iUNPyDQKOaGQ2jJBv0JhGCKGN6iZyzKvSSr87Hq+Y8IA7iHpmslQ7lGaEk1fg/v1NySiwddWpv9ivz21hbPMl2xf26ixvQP47ETWMSH2uXUg4tlIWCT4xEPYKGMamLEoBWlzE5RS7zpQA/vSlhKUwgbdtSVL3ZmZ36TETO0Mw01au59Ot/gsfBkBBA1haVfLfOcF8BTnb/TnUolTfo7GqAzy2lW20C/BvBBr2X/0Kz8f4qViV6bctAmpeGs9aaocbw1CAb6VylU0Bdbl4yH4feAHLvjbkqYten/ZUOYlU7cqdhLyH1GymiGpgZG07N8NLfR/CfeBs4kvuJLddX2r1tGso8GwS8w/OVI17B1p7QUBGb3d2LpBPSwSFQ2nxrXBsG2iyrTOOaZe4ins2TTOcsED17+HLKTbniSBJLqhAO5OUz9llj9PAn3wbGABCa3n96XdE3Uf86Msoy/51bAi66RDpbk/c/JgWDS0DGRdn8qInMnnlj4+JWZvVlDmYbzFAit+0Jkt/y+BoNG++PkUoB78unSW+1PGNl5+148JH54dGqrtwYUceFTSFi2Vp36D8AIs7PqGfq+ex6oMKrNq9bLup5ALV3D+xG9Wautw4k3HLyPI6zh3Bn41ZuL1vwVyXnSWjOyGbjmMwlP14IcI4grl/QGefSe00Hy/XSbzIlCNx6Z47ihvEjC3yFzchhOdMusLjqSVL4s4arSlQPDAMJZR7MjCQQuc/HwTdy7upTSZu8E+4Z8AfBHOS1LiYauieqfkkSVODGfw8v3hpSNlIMeS2ULgOGu6bOdXQl8UzAclbd4myeHz6OTmmodErv7G4Ms2oeTYxLqGfoBirMVOXOwlmBkzkGKH5ArW18WcbhJCsapTSrJry1CYgc8ekpImIByrJxvG8fLI/j8XxRmhV4m/kFnWqJJ1HaZY6S1ABiPvH04c31oBRN5hBHZrOlQXK9ggYSb3IndtiJgOkIEodq/kfCVKkas0Fmqi0KvgpCSYAkseIIuF6y448AiJVA3FaotcAwFAH5K1gUzmQOEXAH3TXPbiLI8hauhxUTR4rWCCmy/iNn8Etq0hlbjcv89xjOeFnJGqzOTNSATygI2U571Rus5bVNdO0BHDGaVKPczDhtXO3/AhEct1jo1Z8VGWCpWcuaiZuXEY7FAeiP1ocQcl0FVYcgZm9EKeuaWDoE37EvYlcQ4pb/JHY/nm7YeX/I3JksAnAL5k1ibqwWWgMg5sD/y0E53CEtox+Ets2ubIBTxqFNOAF1Dtt6gs797zEiUijetobobzLena17hYT1l9ubVneLg4BjGVPLCFzBlr7FvlSHcEHn/BPicqzu3FaZxmP/4MD5vUq1jFeaxmbxDde6k3I0zbEXDvinzuqc70NE1Jshq6SSjH8Qvx3wrphCp5Ci3b4yWNSM+YvdoQjxvTnsqskODwFQJ1te+uEFZAMqO6r7/7F37abvv6ymNruxyGuA8RTz7LK6yOx4XhLXt/QfSNNvGOorCETD4FsB8gDHJgIgstGoefZM8Ue2bJTwfoSQIrLdFfyZYrCZN3fPbfwbLgcwG5fMF9snkFlp+ykSIgtBauPVpqY30qFKB8J5ADVKXsV1ZVxerIMPglR0KCWSZhr5ejgyrsEYx4UDko0+QPJq/mVc6D/4tlYGKUf+pwnu9sM291bgxcekM9tOy61wtWP+dhB4dbLCWU1t2ICo/tOylB6B3aWqH8+pe6PswY4JQCETJzJODUN1jwNQ9g3/OdfHbgUiJfNTXSKLTuXIeFbdiGtX7cKxPanIZC4lRWEixcEOrsCNBZ5LFqDRfciA1oD+EumMVg4WVuBZZVup5aGskUvhup0FAHyFHpnlOfMAZ/zKUDvxAhbPel2U7TgUa7pEpFUDuTQmnI1OBQAVUWb8oP/JbVknvdwDdl+51l1qyIEd+9xV+UZbbFOnCK7KtNYvC/lLxF6XJU72+kMRw4Yi1L2uLWNKfMWsXZH5w8GoJgCE6XnUODYoeXeWb4SKoEIz6ViBdVwl8O+970YjbyK0GM/TKimGq2YK76SVj4iI6LjM1fAjJiv0kTliOX3ZHFizQ9wRZ3yFSEPn0PBAzdbXJO0jD9akX7f5J5u5iKYKbG39rooPRHwJ5TRpgStFNsgftyInrT49jrbEEkEUp8N4m8C3/Hz/mZ3hCUrakN+8KUpbGYu8u42QeUT8n5sPY5LU9hE/hcr9MIo4gUHi9dV8w0EQuzPkTSYjaomfS0SAEIfmwVlisvkDj4lOrEpkIWbHMNOeFCo0KcvsE6YuQcdKlgn+V6P6U9T0/zxw+OuAPHRv7oU+E+A6spJ9/pS4eBPqpaPZZpw/OrFeaPuu9KJeWNchp3AaS8dy+MJI5RFUFSj8zF+ReW77dSqImWTEuzYJHRy33pVnNlpSf7v6wThb+qDwumhb98vBqjjni4ztOFFOSfJud3Ec4+CZtH8YLCXLv1N64daPTvfkIRUHn+D7p7Zfe2bRpXACCtJ//Nw/NaIlrg4U4MuEAPq5cmJaoNXLjo6AWeZO+Gj9JaODltiKO5ZyowUiAFKqx/klQ6LNpRLeBs6wN5y2UQHIn+hKjZkcFyCCkUJbUmWeP4HAV43aszzrbK+NCnK5JyfZFMtA3hu856TlP4T+ICt12jX96ZfRjpL+ALD5u8xL12Ze18yIj06RF/PjoaUpM6vIlpcca+wPU/UmYnkuMgeSpk7djgBn409y5z90Y7OTtkseTjQMO5RX5MgHhPvynSX8RlweuYACDqyTaz1jyPz4p0AMuJXFz9cs7OGmsatiTORPejSjz84GcHNk/6vfXOd6tFkm71LGAbBsHpGuJKdwMc1Kdhe/QmIqUiKLySmR0SztbqNuDhOJEhV1886NmDfByPgeoS9jDB80bcjG5nWNjul/ixcTBTdht7fry6Hnq/6plIpLXLuE3kAT9eTiWpbDGAu+F+LiXZXuz14mk73+4zVTO3gBTAytXs9brmbSBEqgYAeHZOTt0S1CpyXAYcrqb03gKfQG9rBJLuboXctSknquAQNo9mE1UgnjHyEbQOolPVLvhRP7GUtT9EDp7m2p3RQvHEVs1uvTQ8HIx/djtx/7tG50OewfglEslLFg/ugTIbbIuchpFjBj72fi6OdgHSGtdUYX/W8GMyUbOJaOsBPj18KaWTFkJCCulm0Fn0xDwMlbeJqhEPDE/9RayTplMmQYWINGNzZGTfdo/CkXtnbF56iBNubo5cfUfpDOjsGqm+USoVX0C3VuAQ1kOb67nQqWXsUO99foUSN5BT+0ahDdNviMA1TEyUZK0MJnFi5jZBd0JJfHGZAPXHNPspBAW3IEQUpOljwxjR6ys3T65JENhve+W8tL4+g/CjGBbnf21IHxBLIYH/Un5LIWwOPNx4qBv7rc7Tg8h5BapGFzVvBI0eA9eDn1+dxkqOHl67ZasjVRd1S/9QFvqKdILZu+UL/Wa3RQfUq5LsuPSltUunM0AXavZBJP0xgi/dFDHU2cpOUGgki9IRm9DOsdOO+VZaW0bvzkWhds9aHVJ+mk7KErmQdBrRu0KxW/COomAEAqPKQsDUZa1dMd8SIDayJTMT1MeR+3zPpSEVJzp/3jJoWqSav0n1CDo4WXU3OhLg4r0Do+Zz21dCZIgwA/+svMmyHvB9LdBSPMNcmPCS2C7igw9j7WKtIJLVSgtsRTSHEn6gyI3YZXGmj75zYFn9G8bTQl+TGCZue+eEoNuC+RWeeckK1MDx9r6q3IawO2a8sEu0qh0AnBTkXRrhvXKin03DhsJgV607LQTJQXxm5EXS+Q0N11Ln1Y4ZVYF53q86TizlOHkq6sSnGQnBvTRr1BzSPjrNMKen+36gRCfvZYBtKF2taWZ1FRnrcppgpU77j2eboKI0RdNm7vuhMtLMhed8OOrWHEl5BYve2J1cnCaRlMr5uY5YYb3ggoHyapM8SpvQvmi0ak1OriEvAdTgHi/OtXb3CLbJFr0bnefu4ryy1AOZ51jxHgcPhx7IGWWpzCsmU6tboUF/9rWsQff9XjOiAonjOiCeF1akXAAR12erjt3VE+NRWwae7wT0CVNqAtb5/+VSedQaMvreXMLSzqkqKZan4O33jwkioDoHG3e9by6jW+vW/o7dm/gLpnjXldHp1UtAIjX+f2/9mmIJOfBYOAy4gbasChRmZiZVCT1uS0xQxrQdgqzihbheQ0nMJ5EzDx6OrFUw5kByXg8Zm81d1I/PjmBJ4aRgqmIyOZso2s2dWjgpGHDfXDHgx02wIQXxWEejfwdeNQluIo9RWOBEBrr0GunzK/2T56XkPNSm+8/SOnBKZM5LmROrhX10IXMg+3nLlnb8z+osyn6FEgEUiNBNzrlCAOGN7Wii/IHIHJLUW465Bdru7cE45NjDnCfwkw2fWLX7tLVm85QuVtkPqc7QMrivD5TLy7b5PHEw74VrWZ1nOuyrjdts0R5+HbqP2228Fuk01rCO0ahvmm7l+3AXvJT6DguUsVF9NelxYwQ9NTqQmHX+SWoDHHM0OB3OUVj3mTiZAS2KhW8jnthSsT1wKxTYYuNAO/fwCqrAgXRQKbS+LsGEOOoFM2rkdxlVoW92e/yeZ84o0jgw2PG7at62KXt9bdtA/uHA6u1Ba6HUNlFVOWskAkDHk8GL8LjvhapQ0PB50S78ZC+jZ/2M69N7QeTEuuLbll2/slIUk0C8qcAj5zTEyiYJWUK0nNmenY6+DrQcs07UL/ELpLx3qmVwLvzP89Zr1uKIOm5wQ5comgoc1wBhHPVRsuDpsIVFPcwqcqvAFM634Qu+e97j/2wnHpMcr32OuPPDymR+kJpF9XjwqIvxpczA7uSlMXyUHDYGGxq1Edi38pgZ30vrjTJH5SDV8DVe1ZCh7f4Qtdvw7lQy6drVXgd2zB4WwUa9LvvCd+qnFVdDTIkWlbPKGdTfe9JpFAIuwEeOOgK+V/ufXhNqJ9Yx/N72Z1bGd5WafKPzHDVYtuwUn68UGgvlZojcLdv7YLNXgqJvQfc7wdbFiKmT/rCkd7bBxJkw8uF1ZARSo7eAGxTcfpu6jQT4y9el91VrlX77wgkIMoUE7LqPo3f3MVJw8s40+rw1mE3ZV/6ZuIy4E403cJ7fLXe2SoNwQfMLlj8hFyMfBJ4v9KwrAqwomg1rUAmWQ/zj2gGI3gj/tbBw1kSZL8VPMQDW8cbBl6GwYBkrvRqMQ1UK4CCzoy0XvspVejLehQ9jtRP1sIEDnkcv4XLP0WrtIBJJZTkNjkrS3IqQ4Iz/QigAy0RzuImgU9bY5aV0snj5cugemwD7dnkNFlPxvZRrwtVQuBC2LyczYnuHr/AfvmRr9ulMF1MUP1T7gvnckLlMbdckh6Nc4g03mCIekaaubDHmKwWNr6flKbSIfvvHHUPsM9liq9B2MNHEQhAZFRI722Nr9ulp6hN715m04hGwDNUBYmMiHPff0lzFUX3hQEOMh3WcbJckrzyDabQh7KciJjM/V64kiwOnJCmFWWi6b4RD7dGkllRu/t5Ks3QFQWfkG4Qd7x3Ja1wSkXlteEJW+TrhQmBqa5OjlWbpIJjRQ4Nn0XFKsIPCYeFwrc0r4a2u9NV52Q+t+kWqEKjs1+cg30Vcb60pK+5ykW1hFWHO5GeMiJmLW7Te3LyxPmSC0U1CaZC+zMpr/k/pcfFbuby/mkSMEUcZNNc4YwAwa4oDIhop/R8leUtGmJ8QNy7JCaBQie6/q+Ad90lzaBEcsUmjlWiqy/4DlBCM00pfoawSuG1EaNk8hnAAdGRMYYQm7SyZZhW+WM9isFqgZAalzB43X6IDque+TLKxfSbItbKrMX4t2qWAqQCu0y5HX1bhIUYaUrGjJMfawnqEbbnlTxLI+tf732MUk97tisH4NB+yRSPlDSL8XIpvpTnHjZ3F+c7s61b7wOOoPz/OWUopxKgSxmuzNLpQlGjt6PDcPCiGW9K+skUm3lra68Xd0imVjMVXU1DDmjlG3enBfbg036IhY19dHSAywBd3CI0fAY6cdm5hc3G+LRg4dmrgA29StztDts9IQtwaMDkrgwYrvxQCpMxwGKVunQEUaU8XpKKrjT7A0dJmqBIpcoPrnY3hSVZPnJNtczw9htDylUKUWkYn02/D+yVGjMgP756pOaakOFpZvkdFEfwVOggjACluzEAlAvynQKd2e+ww9annPYUZh1Fw1S+5IBa+H5KwskEm8X9thrLoIbqkQrRUZPwgmaigSWc5dG9raYAzFiBAHUEaG9PEIH40fM24/X5jglWu6qHef2tzAQsaj9lEONymBq2g8PGDgs2Z26IvYbwaADQGt8RjmUY5iT+dwSf2sjj24Hen3eZ9ESq/nDsVE/WWVQBZEOdDfX5Zkka479rYRbklrbYc2mdzALc3BZj7kKvqEH+C1kILJiWlLi4jvX7lqLVXVlVfbznYLzzJ6dcKQjqmzZ1QVQ36lVoLV28Xopvp1mAix/5OX3nIpzf5XmNJxM+WqZAsoiog4mxUnG8tvD8yybI2ZaEl3ufQJFXEPXNS8/Hk3NAE7KLKlWPnOyOg0H5gTNuGaYp9Z9uz9P/mQBb5kyqes9sgRH70NKZlM5wRSfFdlnIhF92rVzh970dphvW4eXL9VrRpcrInwucVPKEeHW8hjpkLP8ZEWfAAbv8W6Nd7VmS9HqXWgk9iQ6yn/0iIZUATCrIVHtGHeZBXblf+KNtXWHamzvmThsBOjk5GFL19hBd3NnK7vHQX0mw3vsHyvL4wHuEmirCLPvbo2yem7XxqrWvGzX6TrqbosdNoLC9wvfNrcm1raRkt8QZURmssSH66FC4qtEeHRUuWCfzMnNLVDLayHncyjh+Mvrj+R0PVkan+pAsH52o9mALSKCs9jwXJ0qNi+DrUJZcqzU/x+HSMqSIdhFU3xXEwj/ZAXSyJw+IUHc5obpwfOM3fdbkYECkxbU9rwzC8IIBGDIsHHCsiecUJa+an1p1nA4DW2Mwx97IEcUnHj+MJu0JxYtDqrsxNHK9vtvW8smi3RJTZAqN/srP77k5Zz5Gq3IbfQwxggZBJt9qQdRFBn++mp5bFPHwCDaBVnPbYtY4wlwGjbhVlMTJxfT8TszjCpqbF7syK2zsA7I81siwDkGXEfJ0XRb5lFj6UZo7m8vn3WjxmyXxlYAV7IsB411wVyTWeHxbv4KTcpEllh2+4ZKyZ9yCU/i8MOJ9D/jG09xKa2vQbm9IUgUsPOC/vgSnn3h3sD1wnrz8Rgrz3kzgtudRhReGiTt0G0DrmkoOBWtPj18awA+Eb75HvTxeWh3afu2AY5551LLna/1v4+gQgjk5Mq/LVORh0FOAGAqMsEXmLLEsWAkO5HeMDVkJF6tHGhc8IZdWedePs7NZaDCEGpjSpWMw4FkJQydU596c+8lxOEyXk5AWO880xVgBTRb/UgGEz+1cHasJUVQvS0fWPhJnBW797zS2IJGk1lv7aYmobjUWf9TNOW93PCav+ath5lNq1bogSpbo9GwTcE54DXp3V3wGBmCkji8hGLZEVa+Om86FPuVjvkAuibNzB0GncL9rjIEziLfDyCRLafRCo3JmI4r72WhmceH0wBT+P+iWLGgz0CRvTJHGYs4Ofc3Z/PMeKXijQrw63TDofyi1Z9SU726tQfl9ooLgCRo/KSY4HPsMaeBHSf4NGWwHgKGetCYRW/DFgtBmH6giEhNM0bRec8BCspmw76amgt1k0GXFbLFKLil2OYXR/5GnHVjiXXT2gHBxcRjtXO3koJ8um4mebOcbzuMJIGXAH/FaVK/a9YDy2U6Q+VFwIIhvvcnW2cG1R6lzwB4HkPXiXQtoW5Qo9nNQPMWSgI5Gsed0Avmci2/UxkDYKtggyNSEC7no1SIC6YPPonAWwL1AdRuu8M3wMOBZzAND+V6Wf2BTrG8PXOSK1cbmaCrz2UhOZ3sViSmyeff2fT9Was+mIu6Rz7s1pIdzLhphkwZgEXk4s+0Qlt6Y7tE2U+KEKO7f3NyOk40zdB+3IgAa912iMGEeCmR96pcxEgE5PzTJETNJgHNkI4Pt4wG3UD6/n4/KG5vYlVm0ktkfbV8pqDug2SEViAd8bGYTYSfAx082xSsuv5uqy049pMyPgSmYAXdK3Xxxb2KVDnK1fREBEVNDUi9ObotBHEydF2sR7aBEvJW4PobXHDgW7A9h5B5CZ8ie9+YMr71CvCduggzPBcuBF6pcJZS64SJ41r2LmccnjSmWppvVQvRtSWaMFRwDO4yUTBCkbef7Y1v6dEXpjNr8F1b/JtPiZufIYNjCow4ArMtPlsF6vCL4gUpu17Nq3sYihTcVyebI5op7jOW1tx9rb5PSLp5O4yQOLPZuJi+eYjjp2P9xYkonrNDB/0ely9jf2XqA/vzJCfmTb856/714wJ5dH4ILNsbCvLA0NiLbfCyfuQMSW/t6OrEvRRYKDWw4sCBD2+izjAPJ0at3lHABeU6ePLBAsFeG13yEzvbmhAuK1Qtkd9J3czObKqFCZn58zmyFlkhnEn303y8JUBXojZ3a1Jl8XExb1ZAcPkOT4lCaviZFxTvVxoV2ylx4lKLSM6bnvUrzif2xqYIdJujx8fAwlZJW1b6GA0Jcc+bmzSIh7Jq1p4nfcq7sNzTXwLIkTcoWI6N6O0Zf6ts81XyB9RVRuLLlRibt7yBHemCK9IWDTtSEIO+WgXu+SqkrSRjkkA4B1c7i4ylx67y+wyEyfqC/5mHnZTqeKJ/rKzxfqSgtwvdioLEXT3jl+xdblldCzIxnvosKW/fIjroukYOR0o4ltE13ic1gIAQLAkwztkMjG6H881U7eTonGV2qQmjOP7JGaRAI9nDuYNHCRgR4wFELq3fHUVMxOupa3eVIFG4on2l4duLa3C7tRUZoa2o3Wn3DmVmi3KGMRrCRCUhjkpXPgWhFfsB8rITaYP7EqrfUjCBFKLXqyptnEfBIt0Wz7ZKkDwCMwoKts8pVEBM6RRueMDgIaxWwlztrihK+D+6+AeANSL/R5tMFfIKSySWSE7GyHGSzTxizMDixQR9iIyvRwTY2BHV1vGU98DUR/9H0VpRMxLw5ApkjIWXNFsPTzGsocveVXib1K8KnVnNx0zBJdnVLiSoMV/iKNWrHUCexu/BB0l9cNDi476bVssuWRLKx80O0zzj6EixY10ooF5WZCDgAKVA1latbthfHtV1YW65uqKwDFaA3SrJGulDDRa7H9mdVM+otO3RjI4fllgn6P0yiMo1AiWVUx/TIaxElNqY309gpWPuQPn/uRfzIrENMHR47fBNf1lMBU07wcH0GnwOXpVQvJWwLknKdplz80KgswYSj0r2ZfpZewqyHjPou+eFG8WLwGCwPN9GbWVrvEeAe2p1l+pFw2i6kcZHGKpwvSQ351cTgsgMdc6r8ktcs+t+Is1mZzk9XnWhedyyy8oSwwwLLhNx/xmpstDwjnOGzeeJCLLNjscbZfIBB6vlu8W7RFIyiPB7XIa4BNCLdbJNR+6gfiYd7sZa+AIB/YKAzdOv/Rxg6Rs0dC2+scdVitwQ7U2rMv9Jh1pyDrbkimkhFVGPHWUcmmvTqIK/iMmWezpQxbHcnLh5sGSOYCdMzJTCVk+FMkYfqtE9ObgSdsM9/zRrElrLT4GmuwFukofOIRrtCh5V+PkuxhUHIQJUJTaO/Gm46gWICwKZnG43XtXvqYET2OYdI7h14QeSOn7LauAKHcKm6ZCTtNTIj0d/ZNazaVwCIsOaVZu7BfGvsROjO3ywTWgNZDHH9vXqgQLzcs8OsGIhA+JxBKYrYDzRlZduz/r3cximXmXnT9/WqgpTksiMGadj0HMRqRJ7KEZ5zNQF8uY8w24owOZf5ZxaPA0+98AHYbc7TMU/aTXZlBTFOCjrqAdfGDJh38acREDNl9yybu1BS3kiKl3RRrXfK0jl9XMr02rx6ixRqRl/zMPziLnUYl2eAF2/xVrPeClf3xlq+V2qjtDbVE+qL3I6q8Ur7F/W2THSfq8m31D0dy8np6sefk193Ax36XCGDOosoTt3oytACe0p1qRpv+lMq5sez924d9SkclWg4r6CifogFMzp+CHFwqr9ke39DCZ5Wc5fOEefyRDxUxpCbF2nu9SKdjz+7BWndfE75Wkq0EO3LTJ/8Mzh+wrknQzmmo3clnBRB5KltZNsbkYASz6rEJ3gDkL2rAJmL44ydJBfFkUZTx2Gk4FA/Zo32ZdEL6vy9BZ/kpv/3i/zGQWtOijg9ALU9c0Y929bMfG0xAUnpFbp/bKJ0n+iZwPLYJc7HLLk4QfdkQIyJwYelXl0Fe2B/vVCwjx/Od0VnI3R3nDOwjpqg/2W4A403vpCex2TgkkaqN9il6rWPxajKxP418BvfnOP3m4EQO+jDKYep2ngiZRJCAb88mb0f4fItnhpdQlnl1mm8AHCXQFT6zgVwFwew2f2LISDq9/hF2Tf2+p3k4ERM1U7MvUjEPMTZwVGGSBt9W4l00x4J4jzIh9x42CF5gzsZ4Bl94Ge/kd1betO21wWD2RzF+nMiBnLZ0qepePb4bVHZe5mus5DXewmGLJZq2HsynK5O/Q3Rk++q0kCr7Q/GDMtMKaTcpdRjSraJzjyAGNXxaoA1scBLVx05Yo/sNVWNDylKXEdytcgNGtjyhxWYk4Oadw8CPsLmk0tnhMe4MeZl0Mr/O/jkgH4MtSwG9+RJScKkv4ju91Vf2mzqDII+KkQqUC+blMegOxwiGdq5mBxKJD6HjVgjk7ODbD/iIbUCRkWbCwKeviHqXfQbEGW4Rl/xms7PaI0UIpOUgnVrc+XJ6UDho5/NyTsrLsydyZD/ofdLm6UiVovfkHCTEJ1RH6SzhT8SSpyRLKzrC99VtBGOj96WjShe+Dog3FU7vB0isYyTUJb4WAVuT7UZrw6mBexyl+dApEQtDe8Jbh/4afBsy+zTsd0YQKF2GXqy9PIA8MRLYfEPLH/QQIhpzpS5wx4uOOgh2vU5MJP4tAu9xvnrV8EbDzDLDYhF26Zl+fgbTVU+1Un1XfphsGnaUE8n7pKb62uiTx7M/oJJ+HniY5vsc9sr+jVZRz0R5/SuOpnpqyyxfBrUfSSLfBMR2zNPPUsc2tnbrzLwYEZH9i8K7txw6AMpy07OQ0gqMxJ8Oety9IJTHt9yX7hBa6Wf8s/uOQ3PPCGuj0xblIsS2tka5Upbv9S/HU+Ror/h3uIu+33E5Xzn4j53P0CYPNtWIFVNuHijDnTXIqPxEnLVmBVCOapvft4ZnqVGmu6tOYH++wldrKtKjsor0BVClmtM0NiGFPfOO47EM4HaXH35EcfWJwkwPZ6in4MfSXJrOnO+qvc2DjRqYLJwUsLef44luZkPVvRMOHPHadm3E/DPHd2dvt1ppKXQPiH79ATp5M/PfMTthgRvaXKTebil7/FvUCiDwO5Hhd7eTBvmNVp5nz01eqV0AR58OAD6I80NVr7OK0YIKWh53xRSUlUEtUJ+6SJEy6cIPnorSaQ4l4GwmFI/SKRdrTephdDFpPGmA1wZBdbYVmNTjjegUTFOdeK23YQlRSopsTi+u6a3BpvjcqZ1gTiGiXZeshlsuLJUFU9ForBqC5jmLs9X2gd+g7hhV1mUYgYFOuYI2MxWP8dCeNTpVqRlrnSnvAEe7KY4bKbyGvGGHfg7mhVyL1E0GYBKWtEl6GcGRcOlwznNX5qMfETd/26D/JDmIXCqZigIsSi9WRXDVi/+2H8yVVz9Nqey2X4Bk7tm9vMEoaECytcDHODIEOlVo8YXhAymHauQyEKCon/7YcN6tgQ4IV7VmKxWS9+DJ7gjPQoKrWFEpkT/zwu9k9VuRcYxWbbJrILRrbJQ8Zd4FnAlZcJdusMoSsJCiCtBzNR/Gs6RIONIOmX9vghmXF4VuT296heNhI0Xa8HrJ9c8RSMqiASPEAQMXAHn+pLkmZ7fi7IT+LtxyE3FrzihKs5cQYrB4ERl08+OsK1Mo+eNCNZeTAu3gu1VSNWD8U0xbQl7Ljhzk7AB7l3TtmSVrkvQRNitiw6gE8wcuzS705Fbl9vpaf2nWuUTGZ/Lks0jaNejSrqWXttQWfxzHRg9I5Y3CNccNkkHOndOlIPrrhQKntpX5oH2lG7oyrbwJYhEtcRwegIgQRnmKqEt7EpLxju0sHD9RvyAdkg32qH89gCtI3dSh9aF1X77c8itFH89+9aUu14xg5b9aAeZuQ04duSJWSzorw8GoyGib2DXnLz91pF0qg/SxhukUjFQg3FjJYFY0zG35Zs8wqiEE4V4D84B20uC2uYoQSC9e6OeNAh2qZElFBErLAfOn0Kwgu3Ir2l3Ihwo+wiHSO3zi3ILb0qtMrfECJm0/lOEb4haatiC9NfoRBOFjfmNLN5oABT5dWyVjj0tfyPsSAV2xIm4M72vFwX6AxPJK3/BdXF6/24MlnCCy/7tyMSu97nzoZ0Dc7LzQrDpzAmEGQDL+MZVFPjcPvnouq2OrI12QLPCo/aUWfUjsDscpjp5K3rPzIxrFjQ5PWVNBLIMeC8d/3eNuA/JcFrBMTt6d9JeLV++pJA0nFQUxi+Gjmg153ICTrtcMgRB9f9zaYs2O8/rMqzoZ6XM7uSysRQMoPR4XS8h+V9uuQMwf4zsQk7bgNBVxfmXm+1Vt67Uhr3gMVQ5uSt6cdQ1AjolJRwhb4gLr3wyxCrjljkath89XUuMIGeTONdZNemTN/UvSu4PdTVfZkwqnf5S2Tp5fx2ssfyrWRGNOECA5eeZeJsFNFw7RQDsQMZ+qwI+Ffs/xrDbgJ/o6fNM20CHR5xfiSFGhVVWXjwq50hdzTXeJ2A4qtdVtGGmyxh+B5BCpHD5Wslu80MxgIcqmJTRl0j2/5fa4TFhBHKyr8+xyfeuwVKnj5boAMfReCME5zg9wff0/lVym2i8y7MyX/FwS+BavXKc2uJmy8SywrsCU6ixlXGTklV6v6YmjnOoCep8h4+ymmyTzn6vfG8OQR87aoIj2wrXrxMzAV+b58TJKJl4z1gpNZGwy4g/vw4kqbVBK9R0Fjzz62iWCx7PLhsyNWric5fm/PVTmBfVKHJFBv6469eJOPYFO4aJcuhUcUuc3K4acra7yH8xCOwcfs6fFs/b0DNx5iquey47Fj9P5UzKYoYENCYlrd5j4O5O1BpKIn/3Lthw/YsWg0+FrBrgACn8J0jusx2s+FhTWKn+E0Bh2EOp2NyddoAhChIkRRN1O96IGOxFmm9dAbcmzoEwfnbhSWfy/kqEtSSGrNY5SX9dSelibwT2spwxBnOlCuB6j0IwHpcN7O4aGgwVC5OE2RuUDqxcTRUOSK45AhsSKH1SZq9O+KAVnHGPqQFrubJvu/EY3fH2Hjt13A/Sw00JKR+M1ojgLY5LqxKHMd29UjKbsNXSG5NIRj63wm+bVjJ9WKMDZ9l7pxrrVJk1h9VBoIY74yz7rnm0XoJ+HWm0p5FFYAA+NUJ6Wu/vNCjtmWZXEwjNqBaIhJX6E4qV3OX5ZZCtOuUDpu4+Uz4xS0vHp9b/PCgwhMFGg3oUhG74gxWK3Augk63RhH3d8Gs+puaLTtRY/e27JN7PpTOnC/xj6/T12YNZuFhoycPJ1LCah5Sl6yFXPtmyXLG8QDeATMf0b28Lu5zURDNsqKpIPN9mzndJyzJCpEQEnJKMvh10NJRT4IQVoFOL7zJfqrRP640sCsMc1bkJBDBREITcQa1LXglK8Oc0o6x6ahw/bKtjhiWl4lqhLIG/byufSjr85AV1rx/SFFlh+rnXYSeGPyv5mp+HZw5OYt1MdsxXgatdoNi1YbPjdrJAnC06l9E+RjWET0SX2S77weiUoN79kThm3UGjDakPnvc1z/kOlwVL5wDtWE7qVdX2SJS4xyPJ0Xpq5l4xnu+qhwuapqm082EtWRCeUFvEHRbNCicvPRheIX20jmE9MGN0iMVCfg+muX1gWfOHuwG/BTbeTuCOjYNyIiLP+TaQIlwHIi4YgAJzYzQ2aD96s/ml2GxbjUqLTnz4IhTVSI895PnynTHQfCed9xfktfWHsbe7sDnytHGEqI/di0x/b4cwSTbVxcOBG+nyhO7MfcFPTrYgBNWib9P+2VRmw5vb4rkkikTY39sXbz781vu0n2vVqVd8xugBK+SPioWMNv9kVEScngwIIGZXLsLrYNS41IVG5rDjeiCR8oVCodogUwM5XENQMY7ma9bKPfVXpPWWt5gNZKqgKuMVkyTxh9SFP28CVYxk6AAM70xXaMqCHb9bRXE2fb71K4BlJNEobrU8We3v/7Z8eV99dPXgpywLOuUf+/WwzZdU00arCRVCp64ShYBXnaoQKCJSBOI0EGXMVcwMEQQTmFHI2X/yR/OhijJ5e/t/AH8KvsufUF+n+5G7bkAsQkszOFXM+7dplX0K8GJGGjDHIQOzeMwlpPxLStPnfQxFC5+naiMp6cRbvNQehdzGG/KLJs89E/ZqCG6p+aZ3e6cvBfz1Cbr7Wx7sdyW85EbGDonlFc3GSej0td4sM4uI+dV8dLvPDtY2glVwgvTdfHPhHxjMvQZymNFkRK2m8evSk/HGy4LpXMZBRYJGU1HfqetPuw/fie/xrbR3Jq5nB+WFYLAv4yLGwXKRCtz5wExenWfB7DSz24coKpa1MIwrQKYC9XEvcYFOf/ekkWKJDdU+b0Ad/h+4VxDVRZEVEG+/g5irYleX2DHRSHjOcyrUstdzeHzn1Lk0NztFKJf6yLqfkeUG5c4SA69X+XhHFwwDjt0CvNwlDlZpu5kW6KY5QtMpTGzOn3b4QRDunCFSAqxYahACqIIFC8/6p9P2KfAyBW02c9AWqSbRu52I5oVr2ua+P3Ze3NkGZRA6xtPeSBCUATFzMZiA3FCH/8Fhrh7CtZFP5JM9t4uqW7tM/NjAmqgIyb0qOZbFO2J8Bp87d7F7EZJGSnPhXP4kr72M8uTE7pl0pKz+FxrmyZW8/cPs8XfXibBDRjAakTN8rUmXX1i8vpr+ngKtYjvZDOu7ArU/Cxl4HaOa6LErQ/6WnncxKIVg0HH7+xu6Ejjyw9+BZU3p1dID/ah26HENgGEgURP3My0+mW+gZxCcmp95s9fw7HPQUEoavCIMO2Gk7OFJzOtUovSuOqQ+lRHVwNI4xN950IEkAlQ6ntd0NMTNt6oaveJg+E39OWita2cbytfd/aWx26olYLxWF8enu3aiXMY3JADIvjSJJBGlDKEcJLboxIszEajUcoZdd2tnkq9I3lcwlkDj/wxuWrX5uKTJ+6ceWkgxC2zpz+hxmS74HOUKSVuosSdDtaJmsUGIoF61WC9Xyrbx65zHwyQFG2oDW/ceGhtdV2thimKLfpn9RYdovATHftqD5giL/PvuGfI9rSgZSzOSrUz0AKMGTW1jPWd3FR9cP2Y2CFZ+ey0KrJrBdgH0DoqptXQ4HS/6zfozI23K/2d+cekTqPnKur31gjXWKCmkgNWCqqG90X05K7epomQU1ML3tyd7YUakLOetyVdgWINel4gvT/t3qyzF7ns+hTKfUHqldxrrjWjgfhrB1rORyTFWoV22+/HsJpGiIx11Cob4zZ4O6oUI5l7qKBZHtbwo0LwXZ1b/Oy/jg8RY3IakHjfzqAzm2NLAcbpX1kiMCPoA16GMxC6OdQwUy1a+OVhUNCH8o3Cs2LSyffLvYn/kPMAXkoMpmUQz68fA5y8LJNIG3epcyeTw/J82Lwp16MTQT9CUC1Z4itTDgaNPHHy1DMqHZKcUsGYwPR0C2rsedhIXnKHAjHtTbiFPHRdhZP5Z2YOgpIqqH7Dtb5NO3oVLHOiZXk1TaI9o0irsozAB+Aab1Ix/jsMPSbu+p5pYkKUd2B6T8P/qJNY2g4pPgbGThMRovGGbXDTxJAGRjZGucb+moGoc+Js38C/1mOzvLtZ6unabbcfRWZzri39J4Izm2cP9z78NWs1BrFtAhq1bUgtBhqLSldbp9bsr60fmvGqoBbbBPQm+hlyIcwEFykqICv6kIO9UBBLdy9k1B7fv7mhZMV5JBmOYEK9sE8aFoLHTyvCpYFsdeWS3WDddDiK4bamrDzl0uDmRxzUi8ymsgYfEmMZemd+iStM6cxkpktoXHVHMjgAEalVyk40VB5I0zuXWboU8wkfbj+J2zn47ECkO+auWQ6R2h3j6DLxKEnb1rl9hUSJSr2kAnYMYfIY3WGuMvQuDslXuCoVCod/y6B0OcG12YHOp8oUY/z1i9XCct9DyhZnasSkLAlKLlCv4pIDUMdcjvCLgYroMBRdo96pfjZEvDFZonU5Oqfo+mwtVfe0qulXcyyzQ== \ No newline at end of file diff --git a/py/腾讯视频.py b/py/腾讯视频.py deleted file mode 100644 index 13f98f9..0000000 --- a/py/腾讯视频.py +++ /dev/null @@ -1,264 +0,0 @@ -# coding=utf-8 -import json -import re -import sys - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "腾讯视频" - self.base_host = "https://v.qq.com" - self.header = {"User-Agent": "PC_UA"} - self.classes = [ - {"type_id": "choice", "type_name": "精选"}, - {"type_id": "movie", "type_name": "电影"}, - {"type_id": "tv", "type_name": "电视剧"}, - {"type_id": "variety", "type_name": "综艺"}, - {"type_id": "cartoon", "type_name": "动漫"}, - {"type_id": "child", "type_name": "少儿"}, - {"type_id": "doco", "type_name": "纪录片"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def _headers(self): - return dict(self.header) - - def _parse_list_items(self, html, with_channel=False, channel_id=""): - videos = [] - list_items = re.findall( - r']*class=["\']?list_item["\']?[^>]*>([\s\S]*?)
', - str(html or ""), - re.I, - ) - for item in list_items: - title_match = re.search(r']*alt=["\']?([^"\']*)["\']?', item, re.I) - pic_match = re.search(r']*src=["\']?([^"\'\s>]+)["\']?', item, re.I) - desc_values = [ - re.sub(r"<[^>]*>", "", value).strip() - for value in re.findall(r']*>([\s\S]*?)', item, re.I) - ] - url_match = re.search(r']*data-float=["\']?([^"\'\s>]+)["\']?', item, re.I) - if not title_match or not pic_match: - continue - source_id = url_match.group(1) if url_match else "" - vod_id = f"{channel_id}${source_id}" if with_channel else source_id - videos.append( - { - "vod_id": vod_id, - "vod_name": title_match.group(1) or "", - "vod_pic": pic_match.group(1) or "", - "vod_remarks": next((value for value in reversed(desc_values) if value), ""), - } - ) - return videos - - def homeContent(self, filter): - url = ( - f"{self.base_host}/x/bu/pagesheet/list?_all=1&append=1&channel=cartoon" - "&listpage=1&offset=0&pagesize=21&iarea=-1&sort=18" - ) - response = self.fetch(url, headers=self._headers()) - videos = self._parse_list_items(getattr(response, "text", ""), with_channel=False) - return {"class": self.classes, "list": videos[:20]} - - def homeVideoContent(self): - return {"list": self.homeContent(False).get("list", [])} - - def playerContent(self, flag, id, vipFlags): - return {"parse": 1, "jx": 1, "url": id, "header": self._headers()} - - def _safe_json(self, text, strip_prefix="", strip_suffix=""): - raw = str(text or "") - if strip_prefix and raw.startswith(strip_prefix): - raw = raw[len(strip_prefix):] - if strip_suffix and raw.endswith(strip_suffix): - raw = raw[: -len(strip_suffix)] - return json.loads(raw) if raw else {} - - def _join_text_list(self, values): - parts = [] - for item in values or []: - if isinstance(item, (list, tuple)): - text = next((str(value).strip() for value in item if str(value).strip()), "") - else: - text = str(item).strip() - if text: - parts.append(text) - return ",".join(parts) - - def _get_batch_video_info(self, vids): - results = [] - for start in range(0, len(vids or []), 30): - batch = vids[start:start + 30] - if not batch: - continue - url = ( - "https://union.video.qq.com/fcgi-bin/data?otype=json&tid=1804&appid=20001238" - "&appkey=6c03bbe9658448a4&union_platform=1&idlist=" + ",".join(batch) - ) - response = self.fetch(url, headers=self._headers()) - payload = self._safe_json(getattr(response, "text", ""), strip_prefix="QZOutputJson=", strip_suffix=";") - for item in payload.get("results", []): - fields = item.get("fields", {}) - category_map = fields.get("category_map", []) - results.append( - { - "vid": fields.get("vid", ""), - "title": fields.get("title", ""), - "type": category_map[1] if len(category_map) > 1 else "", - } - ) - return results - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - offset = (page - 1) * 21 - params = [ - "_all=1", - "append=1", - f"channel={tid}", - "listpage=1", - f"offset={offset}", - "pagesize=21", - "iarea=-1", - ] - options = dict(extend or {}) - if options.get("sort"): - params.append(f"sort={options['sort']}") - if options.get("iyear"): - params.append(f"iyear={options['iyear']}") - if options.get("year"): - params.append(f"year={options['year']}") - if options.get("type"): - params.append(f"itype={options['type']}") - if options.get("feature"): - params.append(f"ifeature={options['feature']}") - if options.get("area"): - params.append(f"iarea={options['area']}") - if options.get("itrailer"): - params.append(f"itrailer={options['itrailer']}") - if options.get("sex"): - params.append(f"gender={options['sex']}") - url = f"{self.base_host}/x/bu/pagesheet/list?" + "&".join(params) - response = self.fetch(url, headers=self._headers()) - return { - "list": self._parse_list_items(getattr(response, "text", ""), with_channel=True, channel_id=str(tid)), - "page": page, - "pagecount": 9999, - "limit": 21, - "total": 999999, - } - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids or []: - parts = str(raw_id).split("$", 1) - target_cid = parts[1] if len(parts) > 1 else parts[0] - url = f"https://node.video.qq.com/x/api/float_vinfo2?cid={target_cid}" - try: - payload = self.fetch(url, headers=self._headers()).json() - except Exception: - continue - cover = ((payload.get("c") or {}).get("pic") or "") - vod = { - "vod_id": raw_id, - "vod_name": ((payload.get("c") or {}).get("title") or ""), - "type_name": self._join_text_list(payload.get("typ", []) or []), - "vod_actor": self._join_text_list(payload.get("nam", []) or []), - "vod_year": ((payload.get("c") or {}).get("year") or ""), - "vod_content": ((payload.get("c") or {}).get("description") or ""), - "vod_remarks": payload.get("rec", "") or "", - "vod_pic": cover if cover.startswith("http") else self.base_host + cover, - "vod_play_from": "", - "vod_play_url": "", - } - video_ids = ((payload.get("c") or {}).get("video_ids") or []) - if video_ids: - detail_map = {item.get("vid"): item for item in self._get_batch_video_info(video_ids)} - play_items = [] - for vid in video_ids: - item = detail_map.get(vid, {"title": "", "type": ""}) - display_title = (item.get("title") or "选集").strip() - if re.fullmatch(r"\d+", display_title): - display_title = f"第{display_title}集" - play_items.append(f"{display_title}${self.base_host}/x/cover/{target_cid}/{vid}.html") - vod["vod_play_from"] = "腾讯视频" - vod["vod_play_url"] = "#".join(play_items) - result["list"].append(vod) - return result - - def searchContent(self, key, quick, pg="1"): - url = ( - "https://pbaccess.video.qq.com/trpc.videosearch.mobile_search." - "MultiTerminalSearch/MbSearch?vplatform=2" - ) - headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " - "(KHTML, like Gecko) Chrome/98.0.4758.139 Safari/537.36" - ), - "Content-Type": "application/json", - "Origin": "https://v.qq.com", - "Referer": "https://v.qq.com/", - } - payload = { - "version": "25042201", - "clientType": 1, - "query": key, - "pagenum": int(pg) - 1, - "pagesize": 30, - "extraInfo": { - "isNewMarkLabel": "1", - "multi_terminal_pc": "1", - "themeType": "1", - }, - } - try: - response = self.post(url, headers=headers, json=payload) - data = response.json() - except Exception: - return {"list": [], "page": 1, "pagecount": 1, "limit": 30, "total": 0} - - videos = [] - - def process_item(item): - if not item or not item.get("doc") or not item["doc"].get("id") or not item.get("videoInfo"): - return - if len(item["doc"]["id"]) <= 11: - return - info = item["videoInfo"] - videos.append( - { - "vod_id": item["doc"]["id"], - "vod_name": re.sub(r"", "", info.get("title", "")), - "vod_pic": info.get("imgUrl", ""), - "vod_remarks": info.get("firstLine") or info.get("secondLine") or "", - } - ) - - for item in (((data.get("data") or {}).get("normalList") or {}).get("itemList") or []): - process_item(item) - for area in ((data.get("data") or {}).get("areaBoxList") or []): - for item in (area.get("itemList") or []): - process_item(item) - - page = int(pg) - return { - "list": videos, - "page": page, - "pagecount": page + 1 if len(videos) >= 20 else page, - "limit": 30, - "total": 999 if videos else 0, - } diff --git a/py/腾讯视频.txt b/py/腾讯视频.txt new file mode 100644 index 0000000..3c1230a --- /dev/null +++ b/py/腾讯视频.txt @@ -0,0 +1,15 @@ +// ignore +//@name:腾讯视频 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:J1ADCaiSHuQROAYV +//@ek:base64:i1dWClufZqQPSMZjtk1GFU8HWPvE0gQytlXZQn3ZiUC9I3w/z9XeoD8YV5y7ulUh +//@hash:sha256:0e0496ecec1af030498d17e7cbc02f99f94041900c23398145397571db183669 +//@sig:base64:Hx5Mt0vnRP1F9uVL775ltehjXgIcSnpbxYoXsa8nnSPA+StYIFwJ/IhGBfFUXKAjNu688zbOt3xoZJiopW/jDQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/至臻.py b/py/至臻.py deleted file mode 100644 index 82e6f78..0000000 --- a/py/至臻.py +++ /dev/null @@ -1,268 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "至臻" - self.host = "http://www.miqk.cc" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.categories = [ - {"type_id": "1", "type_name": "至臻电影"}, - {"type_id": "2", "type_name": "至臻剧集"}, - {"type_id": "3", "type_name": "至臻动漫"}, - {"type_id": "4", "type_name": "至臻综艺"}, - {"type_id": "5", "type_name": "至臻短剧"}, - {"type_id": "24", "type_name": "至臻老剧"}, - {"type_id": "26", "type_name": "至臻严选"}, - ] - self.pan_patterns = [ - ("baidu", "百度资源", r"pan\.baidu\.com|yun\.baidu\.com"), - ("a139", "139资源", r"yun\.139\.com"), - ("a189", "天翼资源", r"cloud\.189\.cn"), - ("a123", "123资源", r"123684\.com|123865\.com|123912\.com|123pan\.com"), - ("a115", "115资源", r"115\.com"), - ("quark", "夸克资源", r"pan\.quark\.cn"), - ("xunlei", "迅雷资源", r"pan\.xunlei\.com"), - ("aliyun", "阿里资源", r"aliyundrive\.com|alipan\.com"), - ("uc", "UC资源", r"drive\.uc\.cn"), - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _normalize_img_url(self, img_url): - raw = str(img_url or "").strip() - if not raw: - return "" - matches = list(re.finditer(r"https?://", raw, re.I)) - if len(matches) > 1: - raw = raw[matches[-1].start() :] - return raw - - def _detect_pan_type(self, url): - raw = str(url or "").strip() - for pan_type, title, pattern in self.pan_patterns: - if re.search(pattern, raw, re.I): - return pan_type, title - return "", "" - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for node in root.xpath( - "//*[@id='main']//*[contains(concat(' ', normalize-space(@class), ' '), ' module-item ')]" - ): - href = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//a[@href])[1]/@href") or [""])[0]).strip() - title = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@alt])[1]/@alt") or [""])[0]).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-text')])[1]//text()"))) - year = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-caption')])[1]//span[1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(self._normalize_img_url(pic)), - "vod_remarks": remarks, - "vod_year": year, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_url(f"/index.php/vod/show/id/{tid}/page/{int(pg)}.html") - return self._page_result(self._parse_cards(self._request_html(url)), pg) - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - page = int(pg) - if not keyword: - return {"page": page, "total": 0, "list": []} - - url = self._build_url(f"/index.php/vod/search/page/{page}/wd/{quote(keyword)}.html") - root = self.html(self._request_html(url)) - if root is None: - return {"page": page, "total": 0, "list": []} - - items = [] - for node in root.xpath("//*[contains(@class,'module-search-item')]"): - href = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@href")).strip() - title = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@title")).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'video-serial')][1]//text()")) - or "".join(node.xpath(".//*[contains(@class,'module-item-text')][1]//text()")) - ) - if not href or not title: - continue - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(self._normalize_img_url(pic)), - "vod_remarks": remarks, - } - ) - return {"page": page, "total": len(items), "list": items} - - def _parse_detail_page(self, vod_id, html): - root = self.html(html) - if root is None: - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - detail = { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath("//*[contains(@class,'page-title')][1]//text()"))), - "vod_pic": self._build_url( - self._normalize_img_url( - ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@data-src") or [""])[0] - ).strip() - or ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@src") or [""])[0] - ).strip() - ) - ), - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - for label_node in root.xpath("//*[contains(@class,'video-info-itemtitle')]"): - key = self._clean_text("".join(label_node.xpath(".//text()"))) - sibling = label_node.getnext() - if sibling is None: - continue - values = [self._clean_text(text) for text in sibling.xpath(".//a//text()")] - joined = ",".join([value for value in values if value]) - text_value = self._clean_text("".join(sibling.xpath(".//text()"))) - if "年代" in key: - detail["vod_year"] = joined or text_value - elif "导演" in key: - detail["vod_director"] = joined or text_value - elif "主演" in key: - detail["vod_actor"] = joined or text_value - elif "剧情" in key: - detail["vod_content"] = text_value - - for node in root.xpath("//*[contains(@class,'module-row-info')]//p"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if text: - detail["pan_urls"].append(text) - return detail - - def _build_pan_lines(self, detail): - lines = [] - seen = set() - for url in detail.get("pan_urls", []): - pan_type, title = self._detect_pan_type(url) - if not pan_type or url in seen: - continue - seen.add(url) - lines.append((self.pan_priority.get(pan_type, 999), f"{pan_type}#至臻", f"{title}${url}")) - lines.sort(key=lambda item: item[0]) - return [(item[1], item[2]) for item in lines] - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail = self._parse_detail_page(vod_id, self._request_html(self._build_url(vod_id))) - lines = self._build_pan_lines(detail) - result["list"].append( - { - "vod_id": vod_id, - "vod_name": detail["vod_name"], - "vod_pic": detail["vod_pic"], - "vod_year": detail["vod_year"], - "vod_director": detail["vod_director"], - "vod_actor": detail["vod_actor"], - "vod_content": detail["vod_content"], - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - pan_type, _ = self._detect_pan_type(id) - if pan_type: - return {"parse": 0, "playUrl": "", "url": id} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/至臻.txt b/py/至臻.txt new file mode 100644 index 0000000..97d8108 --- /dev/null +++ b/py/至臻.txt @@ -0,0 +1,15 @@ +// ignore +//@name:至臻 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:zDzGdKVDG7Y85lfo +//@ek:base64:KR3fYFw0jat4D2XooxCFGbMvON/TZFpP4VyAkKKSBexOZF0sb466WK38Vx/1HILk +//@hash:sha256:1238a55c830bea9c6edb5a57ccc8261a4dae509ed586ba48c21abf034d5a6832 +//@sig:base64:/aBm+d6/wHJvcQ3LJjgCasYDPQI+lpGKgAq7dkiqc/xPD/0uK957jNB97WD24WEnJSo0BU9zu+1wWOml1ep6BQ== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/茶杯狐.py b/py/茶杯狐.py deleted file mode 100644 index 6ad73bb..0000000 --- a/py/茶杯狐.py +++ /dev/null @@ -1,522 +0,0 @@ -# coding=utf-8 -import base64 -import hashlib -import json -import random -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "茶杯狐" - self.host = "https://www.cupfox.ai" - self.page_limit = 20 - self.firewall_chars = "PXhw7UT1B0a9kQDKZsjIASmOezxYG4CHo5Jyfg2b8FLpEvRr3WtVnlqMidu6cN" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) " - "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 " - "Mobile/15E148 Safari/604.1" - ), - "Referer": self.host + "/", - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _encode_detail_id(self, href): - movie_match = re.search(r"/movie/([^/?#]+)\.html", self._build_url(href)) - if movie_match: - return f"detail/{movie_match.group(1)}" - video_match = re.search(r"/video/([^/?#]+)\.html", self._build_url(href)) - if video_match: - return f"detail/video/{video_match.group(1)}" - return "" - - def _decode_detail_id(self, vod_id): - raw = str(vod_id or "").strip() - video_match = re.search(r"^detail/video/([^/?#]+)$", raw) - if video_match: - return self._build_url(f"/video/{video_match.group(1)}.html") - movie_match = re.search(r"^detail/(?:movie/)?([^/?#]+)$", raw) - return self._build_url(f"/movie/{movie_match.group(1)}.html") if movie_match else "" - - def _encode_play_id(self, href): - matched = re.search(r"/play/([^/?#]+)\.html", self._build_url(href)) - return f"play/{matched.group(1)}" if matched else "" - - def _decode_play_id(self, play_id): - matched = re.search(r"^play/([^/?#]+)$", str(play_id or "").strip()) - return self._build_url(f"/play/{matched.group(1)}.html") if matched else "" - - def _merge_set_cookie(self, cookie_jar, headers): - values = headers if isinstance(headers, list) else [headers] - for item in values: - first = str(item or "").split(";")[0] - if "=" not in first: - continue - name, value = first.split("=", 1) - if name.strip(): - cookie_jar[name.strip()] = value.strip() - - def _cookie_header(self, cookie_jar): - return "; ".join([f"{key}={value}" for key, value in cookie_jar.items()]) - - def _header_value(self, headers, name, default=None): - if not isinstance(headers, dict): - return default - lowered = str(name or "").lower() - for key, value in headers.items(): - if str(key).lower() == lowered: - return value - return default - - def _extract_firewall_token(self, html_text): - matched = re.search(r'var\s+token\s*=\s*encrypt\("([^"]+)"\)', str(html_text or "")) - return matched.group(1) if matched else "" - - def _cupfox_firewall_encrypt(self, value): - encoded = "" - for char in str(value or ""): - index = self.firewall_chars.find(char) - mapped = char if index == -1 else self.firewall_chars[(index + 3) % 62] - encoded += ( - self.firewall_chars[random.randint(0, 61)] - + mapped - + self.firewall_chars[random.randint(0, 61)] - ) - return base64.b64encode(encoded.encode("utf-8")).decode("utf-8") - - def _request_text(self, url, method="GET", body=None, headers=None): - request_headers = dict(self.headers) - if headers: - request_headers.update(headers) - if method == "POST": - response = self.post(url, data=body, headers=request_headers, timeout=15) - else: - response = self.fetch(url, headers=request_headers, timeout=15) - return { - "status_code": response.status_code, - "text": response.text or "", - "headers": {str(key).lower(): value for key, value in dict(response.headers or {}).items()}, - } - - def _request_with_firewall(self, url): - cookie_jar = {} - first = self._request_text(url) - self._merge_set_cookie(cookie_jar, self._header_value(first["headers"], "set-cookie", [])) - if not re.search(r"人机验证|verifyBox", first["text"] or ""): - if int(first["status_code"] or 0) != 200: - raise ValueError(f"HTTP {first['status_code']} @ {url}") - return first["text"] - - token_raw = self._extract_firewall_token(first["text"]) - if not token_raw: - return first["text"] - - verify_body = ( - "value=" - + quote(self._cupfox_firewall_encrypt(url)) - + "&token=" - + quote(self._cupfox_firewall_encrypt(token_raw)) - ) - verify_headers = { - "Referer": url, - "Origin": self.host, - "Content-Type": "application/x-www-form-urlencoded", - } - cookie_text = self._cookie_header(cookie_jar) - if cookie_text: - verify_headers["Cookie"] = cookie_text - verify = self._request_text( - self.host + "/robot.php", - method="POST", - body=verify_body, - headers=verify_headers, - ) - self._merge_set_cookie(cookie_jar, self._header_value(verify["headers"], "set-cookie", [])) - - second_headers = {} - solved_cookie = self._cookie_header(cookie_jar) - if solved_cookie: - second_headers["Cookie"] = solved_cookie - second = self._request_text(url, headers=second_headers) - if int(second["status_code"] or 0) != 200: - raise ValueError(f"HTTP {second['status_code']} @ {url}") - return second["text"] - - def _extract_player_data(self, html_text): - text = str(html_text or "") - matched = re.search(r"player_aaaa\s*=", text, re.I) - if not matched: - return None - object_start = text.find("{", matched.end()) - if object_start < 0: - return None - raw_object = self._extract_balanced_object(text, object_start) - if not raw_object: - return None - try: - return json.loads(raw_object) - except Exception: - return None - - def _extract_balanced_object(self, text, start_index): - raw = str(text or "") - if start_index < 0 or start_index >= len(raw) or raw[start_index] != "{": - return "" - - depth = 0 - in_string = False - quote_char = "" - escaped = False - - for index in range(start_index, len(raw)): - char = raw[index] - if in_string: - if escaped: - escaped = False - elif char == "\\": - escaped = True - elif char == quote_char: - in_string = False - continue - - if char in ('"', "'"): - in_string = True - quote_char = char - continue - - if char == "{": - depth += 1 - continue - - if char == "}": - depth -= 1 - if depth == 0: - return raw[start_index : index + 1] - - return "" - - def _decode2(self, encoded): - if not encoded: - return "" - lookup = {} - for index, char in enumerate(self.firewall_chars): - lookup[char] = self.firewall_chars[(index + 59) % 62] - try: - raw = base64.b64decode(str(encoded).encode("utf-8")).decode("utf-8") - except Exception: - return "" - result = "" - for index in range(1, len(raw), 3): - result += lookup.get(raw[index], raw[index]) - return result - - def _node_text(self, value): - return re.sub(r"\s+", " ", str(value or "")).strip() - - def _pick_first(self, values): - return values[0] if values else "" - - def _full_url(self, path): - raw = str(path or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return self._build_url(raw) - - def _parse_home_classes(self, html): - root = self.html(html or "") - if root is None: - return [] - classes = [] - for node in root.xpath("//nav[contains(@class,'bm-item-list')]//a[@href]"): - href = self._pick_first(node.xpath("./@href")) - matched = re.search(r"/type/(\d+)\.html", href or "") - name = self._node_text("".join(node.xpath(".//text()"))) - if matched and name: - classes.append({"type_id": matched.group(1), "type_name": name}) - return classes - - def _parse_cards(self, html): - root = self.html(html or "") - if root is None: - return [] - items = [] - seen = set() - for node in root.xpath("//*[contains(@class,'movie-list-item')]"): - href = self._pick_first(node.xpath(".//a[1]/@href")) - vod_id = self._encode_detail_id(href) - if not vod_id or vod_id in seen: - continue - name = self._node_text( - self._pick_first(node.xpath(".//a[1]/@title")) or "".join(node.xpath(".//a[1]//text()")) - ) - pic = self._full_url( - self._pick_first(node.xpath(".//*[contains(@class,'Lazy')][1]/@data-original")) - or self._pick_first(node.xpath(".//*[contains(@class,'Lazy')][1]/@src")) - ) - note = self._node_text("".join(node.xpath(".//*[contains(@class,'movie-item-note')][1]//text()"))) - if not note: - note = self._node_text("".join(node.xpath(".//*[contains(@class,'movie-item-score')][1]//text()"))) - if name: - seen.add(vod_id) - items.append( - {"vod_id": vod_id, "vod_name": name, "vod_pic": pic, "vod_remarks": note} - ) - return items - - def _parse_search_cards(self, html): - root = self.html(html or "") - if root is None: - return [] - items = [] - for node in root.xpath("//*[contains(@class,'vod-search-list')]//*[contains(@class,'box')]"): - href = self._pick_first(node.xpath(".//a[contains(@class,'cover-link')][1]/@href")) - vod_id = self._encode_detail_id(href) - name = self._node_text("".join(node.xpath(".//*[contains(@class,'movie-title')][1]//text()"))) - pic = self._full_url( - self._pick_first(node.xpath(".//*[contains(@class,'Lazy')][1]/@data-original")) - or self._pick_first(node.xpath(".//*[contains(@class,'Lazy')][1]/@src")) - ) - note = self._node_text("".join(node.xpath(".//*[contains(@class,'movie-item-note')][1]//text()"))) - if not note: - note = self._node_text( - "".join(node.xpath(".//*[contains(@class,'meta') and contains(@class,'getop')][1]//text()")) - ) - if vod_id and name: - items.append( - {"vod_id": vod_id, "vod_name": name, "vod_pic": pic, "vod_remarks": note} - ) - return items - - def homeContent(self, filter): - html = self._request_with_firewall(self.host) - return {"class": self._parse_home_classes(html)} - - def homeVideoContent(self): - html = self._request_with_firewall(self.host) - return {"list": self._parse_cards(html)[: self.page_limit]} - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - path = f"/type/{tid}.html" if page == 1 else f"/type/{tid}-{page}.html" - html = self._request_with_firewall(self._build_url(path)) - items = self._parse_cards(html) - return {"page": page, "limit": self.page_limit, "total": page * len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._node_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - html = self._request_with_firewall(self._build_url(f"/search/{keyword}----------{page}---.html")) - items = self._parse_search_cards(html) - if quick: - items = items[:10] - return {"page": page, "limit": self.page_limit, "total": page * len(items), "list": items} - - def detailContent(self, ids): - result = {"list": []} - for vod_id in ids: - url = self._decode_detail_id(vod_id) - if not url: - continue - root = self.html(self._request_with_firewall(url) or "") - if root is None: - continue - lines = [] - tabs = root.xpath("//*[contains(@class,'play_source_tab')]//*[contains(@class,'swiper-slide')]") - for index, box in enumerate(root.xpath("//*[contains(@class,'play_list_box')]")): - from_name = "" - if index < len(tabs): - from_name = self._node_text("".join(tabs[index].xpath(".//text()"))) - if not from_name: - from_name = f"线路{index + 1}" - episodes = [] - for anchor in box.xpath(".//*[contains(@class,'content_playlist')]//a[@href]"): - name = self._node_text("".join(anchor.xpath(".//text()"))) - play_id = self._encode_play_id(self._pick_first(anchor.xpath("./@href"))) - if name and play_id: - episodes.append(f"{name}${play_id}") - if episodes: - lines.append((from_name, "#".join(episodes))) - summary_nodes = root.xpath("//*[contains(@class,'summary') and contains(@class,'detailsTxt')][1]") - vod_content = "" - if summary_nodes: - summary = summary_nodes[0] - texts = [] - for text in summary.xpath(".//text()[not(ancestor::*[contains(@class,'ectogg')])]"): - cleaned = self._node_text(text) - if cleaned: - texts.append(cleaned) - vod_content = self._node_text(" ".join(texts)) - years = [ - self._node_text(text) - for text in root.xpath("//*[contains(@class,'scroll-content')]//a/text()") - ] - year = next((value for value in years if re.match(r"^\d{4}$", value)), "") - result["list"].append( - { - "vod_id": vod_id, - "vod_name": self._node_text( - "".join(root.xpath("//h1[contains(@class,'movie-title')][1]//text()")) - ), - "vod_pic": self._full_url( - self._pick_first(root.xpath("//*[contains(@class,'poster')]//img[1]/@src")) - ), - "vod_content": vod_content, - "vod_year": year, - "vod_director": ",".join( - [ - self._node_text(text) - for text in root.xpath( - "//*[contains(@class,'info-data')][contains(.,'导演')]//a/text()" - ) - if self._node_text(text) - ] - ), - "vod_actor": ",".join( - [ - self._node_text(text) - for text in root.xpath( - "//*[contains(@class,'info-data')][contains(.,'演员')]//a/text()" - ) - if self._node_text(text) - ] - ), - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - ) - return result - - def _base64_decode(self, value): - if not value: - return "" - try: - cleaned = str(value).replace("\n", "").replace("\r", "") - return base64.b64decode(cleaned.encode("utf-8")).decode("utf-8") - except Exception: - return "" - - def _md5(self, value): - return hashlib.md5(str(value or "").encode("utf-8")).hexdigest() - - def _decode1_sign(self, encoded): - try: - first = self._base64_decode(encoded) - key = self._md5("test") - xor_text = "".join( - [chr(ord(first[index]) ^ ord(key[index % len(key)])) for index in range(len(first))] - ) - decoded = self._base64_decode(xor_text) - parts = decoded.split("/") - if len(parts) < 3: - return "" - plain_map = json.loads(self._base64_decode(parts[0])) - cipher_map = json.loads(self._base64_decode(parts[1])) - path = self._base64_decode("/".join(parts[2:])) - output = "" - for char in path: - if char.isalpha() and char in plain_map: - index = cipher_map.index(char) if char in cipher_map else -1 - output += plain_map[index] if index != -1 else char - else: - output += char - return output - except Exception: - return "" - - def _decode_play_url(self, data): - url = str((data or {}).get("url") or "").strip() - mode = int((data or {}).get("urlmode") or 0) - if not url: - return "" - if mode == 1: - return self._decode1_sign(url) - if mode == 2: - return self._decode2(url) - return url - - def _is_placeholder_url(self, url): - value = str(url or "").strip() - if not value: - return True - if not re.match(r"^(https?:)?//", value) and not value.startswith("magnet:"): - return True - return ( - "baidu.com/404.mp4" in value - or re.search(r"/404\.mp4($|[?#])", value) is not None - or re.search(r"(^|[?&])code=403($|&)", value) is not None - or "forbidden" in value.lower() - ) - - def playerContent(self, flag, id, vipFlags): - play_url = self._decode_play_id(id) - if not play_url: - return {"parse": 1, "url": str(id or ""), "header": dict(self.headers)} - try: - html = self._request_with_firewall(play_url) - player = self._extract_player_data(html) or {} - vid = str(player.get("url") or "").strip() - if not vid: - raise ValueError("missing player url") - - encoded_vid = quote(vid, safe="") - muiplayer_url = self.host + "/foxplay/muiplayer.php?vid=" + encoded_vid - api = self._request_text( - self.host + "/foxplay/api.php", - method="POST", - body="vid=" + encoded_vid, - headers={ - "User-Agent": self.headers["User-Agent"], - "Referer": muiplayer_url, - "Origin": self.host, - "X-Requested-With": "XMLHttpRequest", - "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", - "Accept": "*/*", - }, - ) - payload = json.loads(api["text"] or "{}") - real_url = self._decode_play_url(payload.get("data") or {}) - if real_url and not self._is_placeholder_url(real_url): - return { - "parse": 0, - "url": real_url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": muiplayer_url, - }, - } - except Exception: - pass - return { - "parse": 1, - "url": play_url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": play_url, - }, - } diff --git a/py/茶杯狐.txt b/py/茶杯狐.txt new file mode 100644 index 0000000..425a767 --- /dev/null +++ b/py/茶杯狐.txt @@ -0,0 +1,15 @@ +// ignore +//@name:茶杯狐 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:3O2unBYfea1cnVyq +//@ek:base64:/RlrzMQb2zBpf6t32D2XhPZmFhk24OKojibKtAl0y+paDtFjVzac0Pm+ZSC73atF +//@hash:sha256:d3a5aa5c85c8e5d4ab6e4c3b2ad9eca5bd73d5620344e9bdac96a3ba4592f376 +//@sig:base64:+PapQgLrTC5kswnfMgm5aTPVut0c5vQC5v2LCxQxxLz2xXtxj8Z+KX4TizYxANsp8E+Yw8WU7oxGoj7rgIPnCw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/蜡笔.py b/py/蜡笔.py deleted file mode 100644 index 6b818b8..0000000 --- a/py/蜡笔.py +++ /dev/null @@ -1,277 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin, urlsplit - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "蜡笔" - self.hosts = ["http://xiaocgege.shop", "http://fmao.shop"] - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.hosts[0] + "/", - } - self.categories = [ - {"type_id": "29", "type_name": "蜡笔臻彩"}, - {"type_id": "1", "type_name": "蜡笔电影"}, - {"type_id": "2", "type_name": "蜡笔电视剧"}, - {"type_id": "3", "type_name": "蜡笔动漫"}, - {"type_id": "4", "type_name": "蜡笔综艺"}, - {"type_id": "5", "type_name": "蜡笔短剧"}, - {"type_id": "24", "type_name": "蜡笔4K"}, - ] - self.pan_patterns = [ - ("baidu", "百度资源", r"pan\.baidu\.com|yun\.baidu\.com"), - ("a139", "139资源", r"yun\.139\.com"), - ("a189", "天翼资源", r"cloud\.189\.cn"), - ("a123", "123资源", r"123684\.com|123865\.com|123912\.com|123pan\.com"), - ("a115", "115资源", r"115\.com|115cdn\.com"), - ("quark", "夸克资源", r"pan\.quark\.cn|quark\.cn"), - ("xunlei", "迅雷资源", r"pan\.xunlei\.com|xunlei\.com"), - ("aliyun", "阿里资源", r"aliyundrive\.com|alipan\.com"), - ("uc", "UC资源", r"drive\.uc\.cn|uc\.cn"), - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.hosts[0] + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _detect_pan_type(self, url): - raw = str(url or "").strip() - for pan_type, title, pattern in self.pan_patterns: - if re.search(pattern, raw, re.I): - return pan_type, title - return "", "" - - def _request_html(self, path_or_url): - raw = str(path_or_url or "").strip() - relative = raw - if raw.startswith("http"): - parsed = urlsplit(raw) - relative = parsed.path or "/" - if parsed.query: - relative += "?" + parsed.query - - last_error = None - for index, host in enumerate(list(self.hosts)): - target = raw if raw.startswith("http") and raw.startswith(host) else urljoin(host + "/", relative) - try: - headers = dict(self.headers) - headers["Referer"] = host + "/" - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code == 200 and response.text: - if index > 0: - self.hosts.insert(0, self.hosts.pop(index)) - self.headers["Referer"] = self.hosts[0] + "/" - return response.text or "" - except Exception as exc: - last_error = exc - if last_error: - raise last_error - return "" - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for node in root.xpath( - "//*[@id='main']//*[contains(concat(' ', normalize-space(@class), ' '), ' module-item ')]" - ): - href = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//a[@href])[1]/@href") or [""])[0]).strip() - title = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@alt])[1]/@alt") or [""])[0]).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-text')])[1]//text()"))) - year = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-caption')])[1]//span[1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - "vod_year": year, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_url(f"/index.php/vod/type/id/{tid}/page/{int(pg)}.html") - return self._page_result(self._parse_cards(self._request_html(url)), pg) - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - page = int(pg) - if not keyword: - return {"page": page, "total": 0, "list": []} - - url = self._build_url(f"/vodsearch/-------------.html?wd={quote(keyword)}&page={page}") - root = self.html(self._request_html(url)) - if root is None: - return {"page": page, "total": 0, "list": []} - - items = [] - for node in root.xpath("//*[contains(@class,'module-search-item')]"): - href = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@href")).strip() - title = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@title")).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'video-serial')][1]//text()")) - or "".join(node.xpath(".//*[contains(@class,'module-item-text')][1]//text()")) - ) - if not href or not title: - continue - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return {"page": page, "total": len(items), "list": items} - - def _parse_detail_page(self, vod_id, html): - root = self.html(html) - if root is None: - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - detail = { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath("//*[contains(@class,'page-title')][1]//text()"))), - "vod_pic": self._build_url( - ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@data-src") or [""])[0] - ).strip() - or ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@src") or [""])[0] - ).strip() - ), - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - for label_node in root.xpath("//*[contains(@class,'video-info-itemtitle')]"): - key = self._clean_text("".join(label_node.xpath(".//text()"))) - sibling = label_node.getnext() - if sibling is None: - continue - values = [self._clean_text(text) for text in sibling.xpath(".//a//text()")] - joined = ",".join([value for value in values if value]) - text_value = self._clean_text("".join(sibling.xpath(".//text()"))) - if "年代" in key: - detail["vod_year"] = joined or text_value - elif "导演" in key: - detail["vod_director"] = joined or text_value - elif "主演" in key: - detail["vod_actor"] = joined or text_value - elif "剧情" in key: - detail["vod_content"] = text_value - - for node in root.xpath("//*[contains(@class,'module-row-info')]//p"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if text: - detail["pan_urls"].append(text) - return detail - - def _build_pan_lines(self, detail): - lines = [] - seen = set() - for url in detail.get("pan_urls", []): - pan_type, title = self._detect_pan_type(url) - if not pan_type or url in seen: - continue - seen.add(url) - lines.append((self.pan_priority.get(pan_type, 999), f"{pan_type}#蜡笔", f"{title}${url}")) - lines.sort(key=lambda item: item[0]) - return [(item[1], item[2]) for item in lines] - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail = self._parse_detail_page(vod_id, self._request_html(self._build_url(vod_id))) - lines = self._build_pan_lines(detail) - result["list"].append( - { - "vod_id": vod_id, - "vod_name": detail["vod_name"], - "vod_pic": detail["vod_pic"], - "vod_year": detail["vod_year"], - "vod_director": detail["vod_director"], - "vod_actor": detail["vod_actor"], - "vod_content": detail["vod_content"], - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - pan_type, _ = self._detect_pan_type(id) - if pan_type: - return {"parse": 0, "playUrl": "", "url": id} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/蜡笔.txt b/py/蜡笔.txt new file mode 100644 index 0000000..a36b11f --- /dev/null +++ b/py/蜡笔.txt @@ -0,0 +1,15 @@ +// ignore +//@name:蜡笔 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:6eJjUoGuLk/L9BZu +//@ek:base64:2OF4lvoBTc1f862tYqcB4gsFS/756v4HkDzrpes5obNEguilzNpH8Dj73MmgGlDn +//@hash:sha256:887f9fa7579ce6dcc1332bb580a5e3df7421e37d7febc5db3df80e48f5e39ee0 +//@sig:base64:RAf3orfhPQEuwtV9lwzoZUussnkBnfx2UlV7Be8lMOynY1y0rw1QCBINnfU+4RSY4HdTgR45NXrU4JdaPsadBg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/袋鼠影视.py b/py/袋鼠影视.py deleted file mode 100644 index c9137ee..0000000 --- a/py/袋鼠影视.py +++ /dev/null @@ -1,557 +0,0 @@ -# coding=utf-8 -import re -import subprocess -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "袋鼠影视" - self.host = "https://daishuys.com" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) " - "AppleWebKit/605.1.15 (KHTML, like Gecko) " - "Version/17.0 Mobile/15E148 Safari/604.1" - ), - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - "Referer": self.host + "/", - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "电视剧"}, - {"type_id": "3", "type_name": "综艺"}, - {"type_id": "4", "type_name": "动漫"}, - ] - self.filters = { - "1": [ - { - "key": "tid", - "name": "类型", - "value": [ - {"n": "全部", "v": "1"}, - {"n": "动作片", "v": "5"}, - {"n": "喜剧片", "v": "10"}, - {"n": "爱情片", "v": "6"}, - {"n": "科幻片", "v": "7"}, - {"n": "恐怖片", "v": "8"}, - {"n": "战争片", "v": "9"}, - {"n": "剧情片", "v": "12"}, - {"n": "动画片", "v": "41"}, - {"n": "纪录片", "v": "11"}, - ], - }, - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "香港", "v": "香港"}, - {"n": "台湾", "v": "台湾"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - {"n": "美国", "v": "美国"}, - {"n": "英国", "v": "英国"}, - {"n": "印度", "v": "印度"}, - {"n": "法国", "v": "法国"}, - {"n": "泰国", "v": "泰国"}, - ], - }, - { - "key": "year", - "name": "年份", - "value": [ - {"n": "全部", "v": ""}, - {"n": "2026", "v": "2026"}, - {"n": "2025", "v": "2025"}, - {"n": "2024", "v": "2024"}, - {"n": "2023", "v": "2023"}, - {"n": "2022", "v": "2022"}, - {"n": "2021", "v": "2021"}, - {"n": "2020", "v": "2020"}, - ], - }, - ], - "2": [ - { - "key": "tid", - "name": "类型", - "value": [ - {"n": "全部", "v": "2"}, - {"n": "国产剧", "v": "13"}, - {"n": "港台剧", "v": "14"}, - {"n": "欧美剧", "v": "15"}, - {"n": "日韩剧", "v": "16"}, - ], - }, - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "香港", "v": "香港"}, - {"n": "台湾", "v": "台湾"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - {"n": "美国", "v": "美国"}, - {"n": "英国", "v": "英国"}, - ], - }, - { - "key": "year", - "name": "年份", - "value": [ - {"n": "全部", "v": ""}, - {"n": "2026", "v": "2026"}, - {"n": "2025", "v": "2025"}, - {"n": "2024", "v": "2024"}, - {"n": "2023", "v": "2023"}, - {"n": "2022", "v": "2022"}, - ], - }, - ], - "3": [ - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - {"n": "美国", "v": "美国"}, - ], - }, - { - "key": "year", - "name": "年份", - "value": [ - {"n": "全部", "v": ""}, - {"n": "2026", "v": "2026"}, - {"n": "2025", "v": "2025"}, - {"n": "2024", "v": "2024"}, - ], - }, - ], - "4": [ - { - "key": "area", - "name": "地区", - "value": [ - {"n": "全部", "v": ""}, - {"n": "大陆", "v": "大陆"}, - {"n": "日本", "v": "日本"}, - {"n": "韩国", "v": "韩国"}, - {"n": "美国", "v": "美国"}, - ], - }, - { - "key": "year", - "name": "年份", - "value": [ - {"n": "全部", "v": ""}, - {"n": "2026", "v": "2026"}, - {"n": "2025", "v": "2025"}, - {"n": "2024", "v": "2024"}, - ], - }, - ], - } - self.filter_defaults = { - "1": {"tid": "1", "area": "", "year": ""}, - "2": {"tid": "2", "area": "", "year": ""}, - "3": {"tid": "3", "area": "", "year": ""}, - "4": {"tid": "4", "area": "", "year": ""}, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - result = {"class": self.classes} - if filter: - result["filters"] = self.filters - return result - - def homeVideoContent(self): - html = self._request_html(self.host + "/") - root = self.html(html) - if root is None: - return {"list": []} - items = [] - seen = set() - for node in root.xpath("//*[contains(@class,'swiper-container') and contains(@class,'hy-slide')]//a[contains(@class,'videopic')][@href]"): - card = self._parse_card(root, node) - if card and card["vod_id"] not in seen: - seen.add(card["vod_id"]) - items.append(card) - for node in root.xpath("//*[contains(@class,'hy-video-list')]//*[contains(@class,'item')]//a[contains(@class,'videopic')][@href]"): - card = self._parse_card(root, node) - if card and card["vod_id"] not in seen: - seen.add(card["vod_id"]) - items.append(card) - return {"list": items} - - def _build_url(self, path): - raw = str(path or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw) - - def _encode_vod_id(self, href): - matched = re.search(r"/movie/([^/?#]+)\.html", self._build_url(href)) - return f"movie/{matched.group(1)}" if matched else "" - - def _decode_vod_id(self, vod_id): - matched = re.search(r"^movie/([^/?#]+)$", str(vod_id or "").strip()) - return self._build_url(f"/movie/{matched.group(1)}.html") if matched else "" - - def _encode_play_id(self, href): - matched = re.search(r"/play/([^/?#]+)\.html", self._build_url(href)) - return f"play/{matched.group(1)}" if matched else "" - - def _decode_play_id(self, play_id): - matched = re.search(r"^play/([^/?#]+)$", str(play_id or "").strip()) - return self._build_url(f"/play/{matched.group(1)}.html") if matched else "" - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=15, verify=False) - if response.status_code != 200: - return "" - return response.text or "" - - def _normalize_media_url(self, value): - raw = str(value or "").strip().strip("'\"") - if not raw: - return "" - if raw.startswith("//"): - return "https:" + raw - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("/"): - return self._build_url(raw) - return "" - - def _first_text(self, node, expr): - for value in node.xpath(expr): - text = str(value or "").strip() - if text: - return text - return "" - - def _parse_card(self, root, anchor): - href = self._first_text(anchor, "./@href") - vod_id = self._encode_vod_id(href) - if not vod_id: - return None - title = ( - self._first_text(anchor, "./@title") - or self._first_text(anchor, ".//img[1]/@alt") - ) - pic = ( - self._first_text(anchor, "./@data-original") - or self._first_text(anchor, ".//img[1]/@data-original") - or self._first_text(anchor, ".//img[1]/@src") - ) - remarks = self._clean_text("".join(anchor.xpath(".//*[contains(@class,'note')][1]//text()"))) - return { - "vod_id": vod_id, - "vod_name": self._clean_text(title), - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - - def _parse_page_count(self, root): - max_page = 1 - for node in root.xpath("//*[contains(@class,'hy-page')]//a[@href]"): - href = self._first_text(node, "./@href") - match = re.search(r"[?&]page=(\d+)", href) - if match: - max_page = max(max_page, int(match.group(1))) - return max_page - - def _parse_category_cards(self, html): - root = self.html(html) - if root is None: - return [], 1 - items = [] - seen = set() - for node in root.xpath("//*[contains(@class,'hy-video-list')]//*[contains(@class,'item')]//a[contains(@class,'videopic')][@href]"): - card = self._parse_card(root, node) - if card and card["vod_id"] not in seen and card["vod_name"]: - seen.add(card["vod_id"]) - items.append(card) - for node in root.xpath("//*[contains(@class,'hy-video-details')]//*[contains(@class,'item')]//dl[contains(@class,'content')]"): - anchor = node.xpath(".//dt//a[contains(@class,'videopic')][@href]") - if not anchor: - continue - anchor = anchor[0] - href = self._first_text(anchor, "./@href") - vod_id = self._encode_vod_id(href) - if not vod_id or vod_id in seen: - continue - title = self._clean_text( - self._first_text(node, ".//dd//*[contains(@class,'head')]//a[1]//text()") - or self._first_text(node, ".//dd//*[contains(@class,'head')]//h3[1]//text()") - or self._first_text(node, ".//dd//*[contains(@class,'head')]//h5[1]//text()") - ) - pic = ( - self._first_text(anchor, "./@data-original") - or self._first_text(anchor, ".//img[1]/@src") - or "" - ) - style_match = re.search(r"url\(([^)]+)\)", self._first_text(anchor, "./@style")) - if not pic and style_match: - pic = style_match.group(1).strip("'\"") - remarks = self._clean_text("".join(anchor.xpath(".//*[contains(@class,'note')][1]//text()"))) - card = { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - for li in node.xpath(".//li"): - li_text = self._clean_text("".join(li.xpath(".//text()"))) - if li_text.startswith("主演："): - card["vod_actor"] = li_text[3:] - elif li_text.startswith("导演："): - card["vod_director"] = li_text[3:] - elif li_text.startswith("地区："): - card["vod_area"] = li_text[3:] - elif li_text.startswith("年份："): - card["vod_year"] = li_text[3:] - if card["vod_id"] not in seen and card["vod_name"]: - seen.add(card["vod_id"]) - items.append(card) - pagecount = self._parse_page_count(root) - return items, pagecount - - def _build_category_url(self, tid, pg, extend): - defaults = self.filter_defaults.get(str(tid), {"tid": str(tid)}) - merged = {**defaults, **(extend or {})} - tid_val = str(merged.get("tid", tid)) - params = f"searchtype=5&tid={tid_val}&page={int(pg)}" - area = str(merged.get("area", "")) - if area: - params += f"&area={quote(area)}" - year = str(merged.get("year", "")) - if year: - params += f"&year={quote(year)}" - return f"{self.host}/search.php?{params}" - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_category_url(tid, pg, extend) - html = self._request_html(url) - items, pagecount = self._parse_category_cards(html) - page = int(pg) - return { - "page": page, - "pagecount": pagecount, - "limit": len(items) or 20, - "total": pagecount * (len(items) or 20), - "list": items, - } - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "pagecount": 0, "total": 0, "list": []} - search_headers = dict(self.headers) - search_headers["Content-Type"] = "application/x-www-form-urlencoded" - search_headers["Referer"] = f"{self.host}/search.php" - response = self.post( - f"{self.host}/search.php?page={page}", - data=f"searchword={quote(keyword)}", - headers=search_headers, - timeout=15, - verify=False, - ) - if response.status_code != 200: - return {"page": page, "pagecount": 0, "total": 0, "list": []} - html = response.text or "" - items, pagecount = self._parse_category_cards(html) - total_match = re.search(r"相关的.?“(\d+)”.?条结果", html) - total = int(total_match.group(1)) if total_match else len(items) - return { - "page": page, - "pagecount": pagecount or page, - "total": total, - "list": items, - } - - def _parse_detail(self, html, vod_id): - root = self.html(html) - if root is None: - return {"vod_id": vod_id, "vod_name": "", "vod_pic": "", "vod_play_from": "", "vod_play_url": ""} - title = self._clean_text("".join(root.xpath("//h1[contains(@class,'h4')][1]//text() | //h1[1]//text()"))) - pic = "" - detail_anchor = root.xpath("//*[contains(@class,'hy-video-details')]//*[contains(@class,'content')]//dt//a[contains(@class,'videopic')][1]") - if detail_anchor: - pic = ( - self._first_text(detail_anchor[0], ".//img[1]/@src") - or self._first_text(detail_anchor[0], "./@data-original") - ) - remarks = self._clean_text("".join(detail_anchor[0].xpath(".//*[contains(@class,'note')][1]//text()"))) - else: - remarks = "" - info = {} - for li in root.xpath("//*[contains(@class,'hy-video-details')]//li"): - li_text = self._clean_text("".join(li.xpath(".//text()"))) - if li_text.startswith("主演："): - info["vod_actor"] = li_text[3:] - elif li_text.startswith("导演："): - info["vod_director"] = li_text[3:] - elif li_text.startswith("年份："): - info["vod_year"] = li_text[3:] - elif li_text.startswith("地区："): - info["vod_area"] = li_text[3:] - elif li_text.startswith("类型："): - info["type_name"] = li_text[3:] - elif li_text.startswith("语言："): - info["vod_lang"] = li_text[3:] - elif li_text.startswith("又名："): - info["other"] = li_text[3:] - elif li_text.startswith("豆瓣："): - info["vod_douban_score"] = li_text[3:] - content = self._clean_text( - "".join(root.xpath("//*[@id='list3']//*[contains(@class,'plot')][1]//text()")) - or "".join(root.xpath("//*[contains(@class,'plot')][1]//text()")) - ) - play_from = [] - play_urls = [] - for index, panel in enumerate(root.xpath("//*[@id='playlist']//*[contains(@class,'panel')]")): - source_name = ( - self._clean_text(self._first_text(panel, ".//a[contains(@class,'option')][1]/@title")) - or self._clean_text( - "".join( - panel.xpath( - ".//a[contains(@class,'option')][1]//text()" - " | .//a[contains(@class,'option')][1]/text()" - ) - ) - ) - or f"线路{index + 1}" - ) - episodes = [] - for anchor in panel.xpath(".//*[contains(@class,'playlist')]//a[@href]"): - href = self._first_text(anchor, "./@href") - ep_name = self._clean_text(self._first_text(anchor, "./@title") or "".join(anchor.xpath(".//text()"))) - if not href or not ep_name: - continue - play_id = self._encode_play_id(href) - if not play_id: - continue - episodes.append(f"{ep_name}${play_id}") - if episodes: - play_from.append(source_name) - play_urls.append("#".join(episodes)) - return { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - "vod_content": content, - "vod_play_from": "$$$".join(play_from), - "vod_play_url": "$$$".join(play_urls), - **info, - } - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - if not vod_id: - continue - url = self._decode_vod_id(vod_id) - if not url: - url = vod_id if vod_id.startswith(("http://", "https://")) else self._build_url(vod_id) - html = self._request_html(url) - detail = self._parse_detail(html, vod_id) - result["list"].append(detail) - return result - - def _curl_request(self, url, headers=None): - command = ["curl", "-L", "--silent", "--show-error", url] - for key, value in (headers or {}).items(): - command.extend(["-H", f"{key}: {value}"]) - completed = subprocess.run(command, capture_output=True, text=True, check=True, timeout=20) - return {"body": completed.stdout or "", "status_code": 200} - - def _extract_play_url(self, html): - patterns = [ - r'var\s+now\s*=\s*"([^"]+)"', - r"var\s+now\s*=\s*'([^']+)'", - r'var\s+now\s*=\s*((?:https?:)?//[^\s;"\']+)', - ] - for p in patterns: - match = re.search(p, html) - if match: - url = self._normalize_media_url(match.group(1)) - if url: - return url - match = re.search(r'((?:https?:)?//[^\s"\'<>\)]+\.m3u8[^\s"\'<>\)]*)', html) - if match: - return self._normalize_media_url(match.group(1)) - return "" - - def playerContent(self, flag, id, vipFlags): - play_url = str(id or "").strip() - if not play_url: - return {"parse": 1, "jx": 1, "playUrl": "", "url": "", "header": {}} - url = self._decode_play_id(play_url) - if not url: - url = self._build_url(play_url) - headers = dict(self.headers) - headers["Referer"] = url - try: - response = self.fetch(url, headers=headers, timeout=15, verify=False) - html = response.text if response.status_code == 200 else "" - except Exception: - try: - html = self._curl_request(url, headers=headers).get("body", "") - except Exception: - html = "" - direct_url = self._extract_play_url(html) - if direct_url: - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": direct_url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": url, - }, - } - return { - "parse": 1, - "jx": 1, - "playUrl": "", - "url": url, - "header": { - "User-Agent": self.headers["User-Agent"], - "Referer": url, - }, - } diff --git a/py/袋鼠影视.txt b/py/袋鼠影视.txt new file mode 100644 index 0000000..c070504 --- /dev/null +++ b/py/袋鼠影视.txt @@ -0,0 +1,15 @@ +// ignore +//@name:袋鼠影视 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:wG5LFVVaiDvtSiVs +//@ek:base64:syd5avFfKIO7rhHkz/4HBzR1xd5FdKbNW7IjyfwxuE/6s9monz/5ebn+AWCq6afB +//@hash:sha256:2e0c788077206715300f2ef4ee63f07770b07430db80138c20cae279568a96da +//@sig:base64:BqV9PfQBVngtv1j1LhDlbW049AXSqk6/e6djo9+UToYTwlEzJzdl2dcs5L59uHrcOzMhMsCzlHgFwUggS0RDDg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/路漫漫.py b/py/路漫漫.py deleted file mode 100644 index 27a3f94..0000000 --- a/py/路漫漫.py +++ /dev/null @@ -1,318 +0,0 @@ -# coding=utf-8 -import base64 -import json -import re -import sys -from urllib.parse import quote, unquote, urljoin - -from Crypto.Cipher import AES -from Crypto.Util.Padding import unpad - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "路漫漫" - self.host = "https://www.lmm85.com" - self.mobile_ua = ( - "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) " - "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 " - "Mobile/15E148 Safari/604.1" - ) - self.headers = { - "User-Agent": self.mobile_ua, - "Referer": "http://www.lmm50.com/", - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", - } - self.classes = [ - {"type_id": "6", "type_name": "日本动漫"}, - {"type_id": "7", "type_name": "国产动漫"}, - {"type_id": "8", "type_name": "欧美动漫"}, - {"type_id": "3", "type_name": "日本动画电影"}, - {"type_id": "4", "type_name": "国产动画电影"}, - {"type_id": "5", "type_name": "欧美动画电影"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes} - - def _abs_url(self, value): - raw = str(value or "").strip() - if not raw: - return "" - return urljoin(self.host + "/", raw) - - def _encode_vod_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"(/vod/detail/[^?#]+\.html)", raw) - return matched.group(1).lstrip("/") if matched else raw.lstrip("/") - - def _decode_vod_id(self, vod_id): - raw = str(vod_id or "").strip().lstrip("/") - return self._abs_url(raw) - - def _encode_play_id(self, href): - raw = str(href or "").strip() - matched = re.search(r"(/vod/play/[^?#]+\.html)", raw) - return matched.group(1).lstrip("/") if matched else raw.lstrip("/") - - def _decode_play_id(self, play_id): - raw = str(play_id or "").strip().lstrip("/") - return self._abs_url(raw) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "")).strip() - - def _get_html(self, url, headers=None): - request_headers = dict(self.headers) - if headers: - request_headers.update(headers) - response = self.fetch(url, headers=request_headers, timeout=15, verify=False) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - items = [] - seen = set() - for box in root.xpath("//*[contains(@class,'video-img-box')]"): - href = self._clean_text((box.xpath(".//a[1]/@href") or [""])[0]) - title = self._clean_text("".join(box.xpath(".//*[contains(@class,'title')][1]//text()"))) - pic = self._clean_text( - (box.xpath(".//img[1]/@data-src") or box.xpath(".//img[1]/@src") or [""])[0] - ) - remarks = self._clean_text("".join(box.xpath(".//*[contains(@class,'label')][1]//text()"))) - vod_id = self._encode_vod_id(href) - if not vod_id or not title or vod_id in seen: - continue - seen.add(vod_id) - items.append( - { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._abs_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def homeVideoContent(self): - return {"list": self._parse_cards(self._get_html(self.host + "/"))[:20]} - - def categoryContent(self, tid, pg, filter, extend): - page = int(pg) - extend = extend or {} - path = f"/vod/show/id/{tid}" - path += str(extend.get("年代", "") or "") - path += str(extend.get("排序", "") or "") - path += f"/page/{page}.html" - items = self._parse_cards(self._get_html(self.host + path)) - return {"page": page, "total": len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = int(pg) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "total": 0, "list": []} - url = f"{self.host}/vod/search/page/{page}/wd/{quote(keyword)}.html" - items = self._parse_cards(self._get_html(url)) - return {"page": page, "total": len(items), "list": items[:10] if quick else items} - - def _parse_play_groups(self, root): - groups = [] - tabs = root.xpath("//*[contains(@class,'module-tab-item') and contains(@class,'tab-item')]") - for index, tab in enumerate(tabs): - name = self._clean_text("".join(tab.xpath(".//text()"))) - target = self._clean_text((tab.xpath("./@href") or [""])[0]) - if not name: - continue - playlist = [] - if target.startswith("#"): - playlist = root.xpath(f"//*[@id='{target[1:]}']") - if not playlist: - playlist = root.xpath(f"(//*[contains(@class,'module-player-list')])[{index + 1}]") - if not playlist: - continue - episodes = [] - for anchor in playlist[0].xpath(".//a[@href]"): - ep_name = self._clean_text("".join(anchor.xpath(".//text()"))) - ep_id = self._encode_play_id((anchor.xpath("./@href") or [""])[0]) - if ep_name and ep_id: - episodes.append(f"{ep_name}${ep_id}") - if episodes: - groups.append((name, "#".join(episodes))) - if groups: - return groups - - fallback = [] - for anchor in root.xpath("//*[contains(@class,'module-player-list')]//a[@href]"): - ep_name = self._clean_text("".join(anchor.xpath(".//text()"))) - ep_id = self._encode_play_id((anchor.xpath("./@href") or [""])[0]) - if ep_name and ep_id: - fallback.append(f"{ep_name}${ep_id}") - if fallback: - return [("播放列表", "#".join(fallback))] - return [] - - def detailContent(self, ids): - raw_id = ids[0] if isinstance(ids, list) else ids - html = self._get_html(self._decode_vod_id(raw_id)) - root = self.html(html) - if root is None: - return {"list": []} - groups = self._parse_play_groups(root) - remarks = [ - self._clean_text("".join(node.xpath(".//text()"))) - for node in root.xpath("//*[contains(@class,'video-info-items')]") - ] - pic = ( - root.xpath("//*[contains(@class,'module-item-pic')]//img[1]/@data-src") - or root.xpath("//*[contains(@class,'module-item-pic')]//img[1]/@src") - or [""] - )[0] - vod = { - "vod_id": str(raw_id), - "vod_name": self._clean_text("".join(root.xpath("//*[contains(@class,'page-title')][1]//text()"))), - "vod_pic": self._abs_url(pic), - "vod_content": self._clean_text("".join(root.xpath("//*[contains(@class,'video-info-content')][1]//text()"))), - "vod_remarks": " / ".join([value for value in remarks if value]), - "vod_play_from": "$$$".join(name for name, _ in groups), - "vod_play_url": "$$$".join(urls for _, urls in groups), - } - return {"list": [vod]} - - def _decode_player_url(self, raw_url, encrypt): - value = str(raw_url or "").strip() - mode = str(encrypt or "0").strip() - if mode == "1": - return unquote(value) - if mode == "2": - try: - return unquote(base64.b64decode(value).decode("utf-8")) - except Exception: - return "" - return value - - def _extract_player_data(self, html): - matched = re.search(r"player_[a-z0-9_]+\s*=\s*(\{[\s\S]*?\})\s*;?", str(html or ""), re.I) - if not matched: - return {} - try: - return json.loads(matched.group(1)) - except Exception: - return {} - - def _decrypt_token(self, token): - try: - payload = base64.b64decode(str(token or "")) - cipher = AES.new(b"ejjooopppqqqrwww", AES.MODE_CBC, b"1348987635684651") - value = unpad(cipher.decrypt(payload), AES.block_size) - return value.decode("utf-8") - except Exception: - return "" - - def _is_media_url(self, url): - return bool(re.search(r"\.(m3u8|mp4|flv|avi|mkv|ts)(?:[?#]|$)", str(url or ""), re.I)) - - def _build_player_headers(self, referer): - return { - "User-Agent": self.mobile_ua, - "Referer": referer, - "Origin": self.host, - } - - def _post_json(self, url, data, referer=None): - headers = self._build_player_headers(referer or self.host) - response = self.post(url, data=data, headers=headers, timeout=10, verify=False) - if response.status_code != 200: - return {} - try: - return json.loads(response.text or "{}") - except Exception: - return {} - - def _extract_js_src(self, js_text, video_url, play_page_url): - matched = re.search(r"\.src\s*=\s*(.*?);", str(js_text or "")) - if not matched: - return "" - raw = re.sub(r"[\+\s']", "", matched.group(1)) - raw = raw.replace("MacPlayer.PlayUrl", video_url) - raw = raw.replace("window.location.href", play_page_url) - if "acfun58.php?id=" in raw or "yun.92cj.com" in raw: - raw = raw.replace("MacPlayer.Parse", "") - else: - raw = raw.replace("MacPlayer.Parse", self.host + "/?url=") - return raw - - def _build_tudou_yunbox_url(self, video_url, play_page_url): - raw = str(video_url or "").strip() - source_type = "" - vid = raw - matched = re.search(r"[?&]t=([^&]+)$", raw) - if matched: - source_type = matched.group(1) - vid = raw[: matched.start()] - vid = vid.replace("+", " ") - return ( - "https://yun.92cj.com/yunbox/" - f"?type={quote(source_type)}&vid={quote(vid)}&referer={play_page_url}" - ) - - def _resolve_player_url(self, player, play_page_url): - media = self._decode_player_url(player.get("url", ""), player.get("encrypt", "0")) - if self._is_media_url(media): - return media.split("&", 1)[0] - source = self._clean_text(player.get("from", "")) - if not media or not source: - return "" - js_url = f"{self.host}/static/player/{source}.js" - js_text = self._get_html(js_url, headers={"Referer": play_page_url}) - parser_page_url = "" - if source == "tudou": - parser_page_url = self._build_tudou_yunbox_url(media, play_page_url) - else: - parser_page_url = self._extract_js_src(js_text, media, play_page_url) - if not parser_page_url or ("type=" not in parser_page_url and source != "tudou"): - return "" - iframe_html = self._get_html(parser_page_url, headers={"Referer": play_page_url}) - if not re.search(r'vid\s*=\s*".+?"', iframe_html): - return "" - api_path = self.regStr(r'post\("(.*?)"', iframe_html) - if not api_path: - return "" - post_url = urljoin(parser_page_url, api_path.lstrip("/")) - token = self.regStr(r'token\s*=\s*"(.*?)"', iframe_html) - payload = { - "vid": self.regStr(r'vid\s*=\s*"(.*?)"', iframe_html), - "t": self.regStr(r'\bvar\s+t\s*=\s*"(.*?)"', iframe_html), - "token": self._decrypt_token(token), - "act": self.regStr(r'act\s*=\s*"(.*?)"', iframe_html), - "play": self.regStr(r'play\s*=\s*"(.*?)"', iframe_html), - } - post_referer = parser_page_url if source == "tudou" else self.host - data = self._post_json(post_url, payload, referer=post_referer) - return str(data.get("url", "")).strip() - - def playerContent(self, flag, id, vipFlags): - play_page_url = self._decode_play_id(id) - if self._is_media_url(play_page_url): - return {"parse": 0, "url": play_page_url, "header": self._build_player_headers(self.host + "/")} - body = self._get_html(play_page_url, headers={"Referer": self.host + "/"}) - player = self._extract_player_data(body) - real_url = self._resolve_player_url(player, play_page_url) - if real_url: - return {"parse": 0, "url": real_url, "header": self._build_player_headers(play_page_url)} - return {"parse": 1, "url": play_page_url, "header": self._build_player_headers(self.host + "/")} diff --git a/py/路漫漫.txt b/py/路漫漫.txt new file mode 100644 index 0000000..14e71ad --- /dev/null +++ b/py/路漫漫.txt @@ -0,0 +1,15 @@ +// ignore +//@name:路漫漫 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:dzGZS7Lz0lRIGfCJ +//@ek:base64:cjwSBAGtpKf0hw8UVCQ11ZC6dL4MTCpCWSQKgkdE+sVDs8SpAsWR1BgYj+8pmmLd +//@hash:sha256:0ab0224a9ee4897af38021dbf93d9a0ea71b21b485db2142232104cb06783e19 +//@sig:base64:3vQNnKEtzi0dE3rISiWQMfXdSH5dYwuhZK8eoUTjD+lwp3Kdg4h5X0LJHJ7yMFKCLFzSDLvS0BdJodB4lJFYAw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/酷我听书.py b/py/酷我听书.py deleted file mode 100644 index 743a96f..0000000 --- a/py/酷我听书.py +++ /dev/null @@ -1,511 +0,0 @@ -# coding=utf-8 -import json -import sys - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "酷我听书" - self.api_host = "http://tingshu.kuwo.cn" - self.search_host = "http://search.kuwo.cn" - self.play_host = "http://mobi.kuwo.cn" - self.parse_api = "https://music-api.gdstudio.xyz/api.php" - self.ua = "kwplayer_ar_9.1.8.1_tvivo.apk" - self.headers = { - "User-Agent": self.ua, - "Referer": self.api_host, - } - self.classes = [ - {"type_id": "2", "type_name": "有声小说"}, - {"type_id": "37", "type_name": "音乐金曲"}, - {"type_id": "5", "type_name": "相声评书"}, - {"type_id": "62", "type_name": "影视原声"}, - ] - self.class_filters = { - "2": [ - {"n": "都市传说", "v": "42"}, - {"n": "玄幻奇幻", "v": "44"}, - {"n": "武侠仙侠", "v": "48"}, - {"n": "穿越架空", "v": "52"}, - {"n": "科幻竞技", "v": "57"}, - {"n": "幻想言情", "v": "169"}, - {"n": "独家定制", "v": "170"}, - {"n": "古代言情", "v": "207"}, - {"n": "影视原著", "v": "213"}, - {"n": "悬疑推理", "v": "45"}, - {"n": "历史军事", "v": "56"}, - {"n": "现代言情", "v": "41"}, - {"n": "青春校园", "v": "55"}, - {"n": "文学名著", "v": "61"}, - ], - "5": [ - {"n": "评书大全", "v": "220"}, - {"n": "小品合辑", "v": "221"}, - {"n": "单口相声", "v": "219"}, - {"n": "热门相声", "v": "218"}, - {"n": "相声名家", "v": "290"}, - {"n": "粤语评书", "v": "320"}, - {"n": "相声新人", "v": "222"}, - {"n": "张少佐", "v": "313"}, - {"n": "刘立福", "v": "314"}, - {"n": "刘兰芳", "v": "309"}, - {"n": "连丽如", "v": "311"}, - {"n": "田占义", "v": "317"}, - {"n": "袁阔成", "v": "310"}, - {"n": "孙一", "v": "315"}, - {"n": "王玥波", "v": "316"}, - {"n": "单田芳", "v": "217"}, - {"n": "关永超", "v": "325"}, - {"n": "马长辉", "v": "326"}, - {"n": "赵维莉", "v": "327"}, - {"n": "潮剧", "v": "1718"}, - {"n": "沪剧", "v": "1719"}, - {"n": "晋剧", "v": "1720"}, - ], - "37": [ - {"n": "抖音神曲", "v": "253"}, - {"n": "怀旧老歌", "v": "252"}, - {"n": "创作翻唱", "v": "248"}, - {"n": "催眠", "v": "254"}, - {"n": "古风", "v": "255"}, - {"n": "博客周刊", "v": "1423"}, - {"n": "民谣", "v": "1409"}, - {"n": "纯音乐", "v": "1408"}, - {"n": "3D电音", "v": "1407"}, - {"n": "音乐课程", "v": "1380"}, - {"n": "音乐推荐", "v": "250"}, - {"n": "音乐故事", "v": "247"}, - {"n": "情感推荐", "v": "246"}, - {"n": "儿童音乐", "v": "249"}, - ], - "62": [ - {"n": "影视广播", "v": "1485"}, - {"n": "影视解读", "v": "1483"}, - {"n": "影视原著", "v": "1486"}, - {"n": "陪你追剧", "v": "1398"}, - {"n": "经典原声", "v": "1482"}, - ], - } - self.default_class = {"2": "42", "37": "253", "5": "220", "62": "1485"} - self.vip_filter = { - "key": "vip", - "name": "权限", - "init": "", - "value": [ - {"n": "全部权限", "v": ""}, - {"n": "免费权限", "v": "0"}, - {"n": "会员权限", "v": "1"}, - ], - } - self.sort_filter = { - "key": "sort", - "name": "排序", - "init": "tsScore", - "value": [ - {"n": "综合排序", "v": "tsScore"}, - {"n": "最新上架", "v": "pubDate"}, - {"n": "按总播放", "v": "playCnt"}, - ], - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def _format_play_count(self, count): - value = int(count or 0) - if value >= 100000000: - return f"{value / 100000000:.1f}亿" - if value >= 10000: - return f"{value / 10000:.1f}万" - return str(value) - - def _is_paid_track(self, track): - pay_info = (track or {}).get("payInfo") or {} - fee_type = pay_info.get("feeType") or {} - return str(fee_type.get("bookvip", "0")) == "1" - - def _parse_search_payload(self, text): - raw = str(text or "").strip() - if not raw: - return {} - try: - return json.loads(raw) - except json.JSONDecodeError: - try: - return json.loads(raw.replace("'", '"')) - except json.JSONDecodeError: - return {} - - def _api_get(self, path, params=None, host=None, headers=None): - target_host = str(host or self.api_host).rstrip("/") - target = path if str(path or "").startswith("http") else f"{target_host}/{str(path or '').lstrip('/')}" - request_headers = dict(self.headers) - request_headers["Referer"] = target_host - if headers: - request_headers.update(headers) - try: - response = self.fetch(target, params=params, headers=request_headers, timeout=10, verify=False) - except Exception: - return {} - if response.status_code != 200: - return {} - body = response.text or "" - if not body.strip(): - return {} - try: - return json.loads(body) - except json.JSONDecodeError: - return body - - def _search_get(self, path, params=None): - payload = self._api_get(path, params=params, host=self.search_host) - if isinstance(payload, str): - return self._parse_search_payload(payload) - return payload or {} - - def _normalize_vod(self, item, category_name=""): - data = item or {} - vip_tag = "会员" if str(data.get("vip", "0")) == "1" else "免费" - play_count = self._format_play_count(data.get("playCnt")) - suffix = category_name or str(data.get("artist") or "") - return { - "vod_id": str(data.get("albumId", "")), - "vod_name": str(data.get("albumName", "")), - "vod_pic": str(data.get("coverImg", "")), - "vod_remarks": f"{vip_tag} | {play_count}次播放 | {suffix}".strip(), - } - - def _build_filters(self): - filters = {} - for item in self.classes: - filters[item["type_id"]] = [ - { - "key": "class", - "name": "类型", - "init": self.default_class[item["type_id"]], - "value": list(self.class_filters[item["type_id"]]), - }, - self.vip_filter, - self.sort_filter, - ] - return filters - - def homeContent(self, filter): - return { - "class": self.classes, - "filters": self._build_filters(), - "list": self.homeVideoContent()["list"], - } - - def homeVideoContent(self): - videos = [] - for item in self.classes: - payload = self._api_get( - "/v2/api/search/filter/albums", - { - "classifyId": self.default_class[item["type_id"]], - "notrace": 0, - "source": self.ua, - "platform": 1, - "uid": 2511482006, - "sortType": "tsScore", - "loginUid": 540339516, - "bksource": "kwbook_ar_9.1.8.1_tvivo.apk", - "rn": 12, - "categoryId": item["type_id"], - "pn": 1, - }, - ) or {} - for row in ((payload.get("data") or {}).get("data") or []): - videos.append(self._normalize_vod(row, item["type_name"])) - return {"list": videos} - - def _fetch_category_page(self, tid, page, classify_id, sort_type): - payload = self._api_get( - "/v2/api/search/filter/albums", - { - "classifyId": classify_id, - "notrace": 0, - "source": self.ua, - "platform": 1, - "uid": 2511482006, - "sortType": sort_type, - "loginUid": 540339516, - "bksource": "kwbook_ar_9.1.8.1_tvivo.apk", - "rn": 21, - "categoryId": tid, - "pn": page, - }, - ) or {} - return ((payload.get("data") or {}).get("data") or []) - - def _force_page_fetch(self, tid, page, classify_id, sort_type, vip_value): - current_page = page - attempts = 0 - while attempts < 10: - items = self._fetch_category_page(tid, current_page, classify_id, sort_type) - if not items: - attempts += 1 - current_page += 1 - continue - if vip_value in ("0", "1"): - items = [item for item in items if str(item.get("vip", "")) == vip_value] - if items or vip_value == "": - return items, current_page, len(items) >= 21 - attempts += 1 - current_page += 1 - return [], current_page, False - - def categoryContent(self, tid, pg, filter, extend): - tid = str(tid) - page = int(pg) - type_ids = {item["type_id"] for item in self.classes} - if tid not in type_ids: - return {"page": page, "limit": 21, "total": 0, "list": []} - - options = dict(extend or {}) - classify_id = str(options.get("class") or self.default_class[tid]) - vip_value = str(options.get("vip", self.vip_filter["init"])) - sort_type = str(options.get("sort") or self.sort_filter["init"]) - items, actual_page, has_more = self._force_page_fetch(tid, page, classify_id, sort_type, vip_value) - del actual_page - category_name = next((item["type_name"] for item in self.classes if item["type_id"] == tid), "") - return { - "page": page, - "limit": 21, - "total": 999999 if has_more else len(items), - "list": [self._normalize_vod(item, category_name) for item in items], - } - - def searchContent(self, key, quick, pg="1"): - keyword = str(key or "").strip() - page = int(pg) - if not keyword: - return {"page": page, "limit": 0, "total": 0, "list": []} - - payload = self._search_get( - "/r.s", - { - "client": "kt", - "all": keyword, - "ft": "album", - "newsearch": 1, - "itemset": "web_2013", - "cluster": 0, - "pn": page - 1, - "rn": 21, - "rformat": "json", - "encoding": "utf8", - "show_copyright_off": 1, - "vipver": "MUSIC_8.0.3.0_BCS75", - "show_series_listen": 1, - "version": "9.1.8.1", - }, - ) - items = [] - for item in payload.get("albumlist") or []: - vip_tag = "会员" if str(item.get("vip", "0")) == "1" else "免费" - items.append( - { - "vod_id": str(item.get("DC_TARGETID", "")), - "vod_name": str(item.get("name", "")), - "vod_pic": str(item.get("img", "")), - "vod_remarks": f"{vip_tag} | {str(item.get('artist', '')).strip()}".strip(), - } - ) - return { - "page": page, - "limit": 21, - "total": int(payload.get("TOTAL") or len(items)), - "list": items, - } - - def _build_play_id(self, rid, is_vip): - return f"{'vip' if is_vip else 'free'}|{rid}" - - def _build_cover(self, image): - image = str(image or "") - if image and not image.startswith("http"): - return f"http://img3.sycdn.kuwo.cn/star/albumcover/240/{image}" - return image - - def _fetch_album_detail_page(self, album_id, page, page_size=2000): - return self._search_get( - "/r.s", - { - "stype": "albuminfo", - "user": "8d378d72qw28f5f4", - "uid": 2511552006, - "loginUid": 540129516, - "loginSid": 958467960, - "prod": "kwplayer_ar_9.1.8.1", - "bkprod": "kwbook_ar_9.1.8.1", - "source": self.ua, - "bksource": "kwbook_ar_9.1.8.1_tvivo.apk", - "corp": "kuwo", - "albumid": album_id, - "pn": page, - "rn": page_size, - "show_copyright_off": 1, - "vipver": "MUSIC_8.2.0.0_BCS17", - "mobi": 1, - "iskwbook": 1, - }, - ) or {} - - def _fetch_album_detail(self, album_id, page_size=2000, max_pages=20): - merged_payload = {} - tracks = [] - seen_track_ids = set() - total_expected = 0 - - for page in range(max_pages): - payload = self._fetch_album_detail_page(album_id, page, page_size) - page_tracks = payload.get("musiclist") or [] - if not payload and page == 0: - return {} - if not merged_payload and payload: - merged_payload = dict(payload) - elif payload: - for key, value in payload.items(): - if key == "musiclist": - continue - if merged_payload.get(key) in ("", None, [], {}) and value not in ("", None, [], {}): - merged_payload[key] = value - - songnum = payload.get("songnum") or merged_payload.get("songnum") - try: - total_expected = int(songnum or 0) - except (TypeError, ValueError): - total_expected = 0 - - added = 0 - for track in page_tracks: - track_id = str(track.get("musicrid") or "") - dedupe_key = track_id or f"{track.get('name', '')}|{len(tracks)}" - if dedupe_key in seen_track_ids: - continue - seen_track_ids.add(dedupe_key) - tracks.append(track) - added += 1 - - if not page_tracks or added == 0: - break - if total_expected and len(tracks) >= total_expected: - break - if len(page_tracks) < page_size: - break - - if not tracks: - return {} - merged_payload["musiclist"] = tracks - if total_expected: - merged_payload["songnum"] = str(total_expected) - return merged_payload - - def detailContent(self, ids): - album_id = str(ids[0] if isinstance(ids, list) and ids else ids).strip() - if not album_id: - return {"list": []} - - payload = self._fetch_album_detail(album_id) - tracks = payload.get("musiclist") or [] - if not tracks: - return {"list": []} - - play_items = [] - total_play = 0 - for index, track in enumerate(tracks, start=1): - total_play += int(track.get("playcnt") or 0) - is_vip = self._is_paid_track(track) - name = str(track.get("name") or f"第{index}集") - display_name = f"💎{name}" if is_vip else name - play_items.append(f"{index}.{display_name}${self._build_play_id(track.get('musicrid'), is_vip)}") - - is_finished = str(payload.get("finished", "0")) == "1" - vip_tag = "会员" if str(payload.get("vip", "0")) == "1" else "免费" - pub = str(payload.get("pub") or "") - return { - "list": [ - { - "vod_id": album_id, - "vod_name": str(payload.get("name") or ""), - "vod_pic": self._build_cover(payload.get("img")), - "vod_remarks": ( - f"{vip_tag} | {'已完结' if is_finished else '连载中'} | " - f"共{payload.get('songnum') or len(tracks)}集 | {self._format_play_count(total_play)}播放" - ), - "vod_content": str(payload.get("info") or payload.get("title") or ""), - "vod_actor": str(payload.get("artist") or ""), - "vod_director": str(payload.get("company") or ""), - "vod_year": f"{pub.split('-')[0]}年" if pub else "", - "vod_area": str(payload.get("lang") or ""), - "vod_lang": str(payload.get("lang") or ""), - "vod_time": pub, - "vod_tag": "完结" if is_finished else "连载", - "vod_play_from": "酷我听书", - "vod_play_url": "#".join(play_items), - } - ] - } - - def _resolve_free_play(self, rid): - params = { - "f": "web", - "source": "kwplayerhd_ar_4.3.0.8_tianbao_T1A_qirui.apk", - "type": "convert_url_with_sign", - "rid": rid, - "br": "320kmp3", - } - payload = self._api_get("/mobi.s", params=params, host=self.play_host) or {} - url = ((payload.get("data") or {}).get("url") or "") - if not url: - url = ( - f"{self.play_host}/mobi.s?f=web&source=kwplayerhd_ar_4.3.0.8_tianbao_T1A_qirui.apk" - f"&type=convert_url_with_sign&rid={rid}&br=320kmp3" - ) - return { - "parse": 0, - "url": url, - "header": {"User-Agent": self.ua, "Referer": self.api_host}, - } - - def _resolve_vip_play(self, rid): - params = { - "use_xbridge3": "true", - "loader_name": "forest", - "need_sec_link": "1", - "sec_link_scene": "im", - "theme": "light", - "types": "url", - "source": "kuwo", - "id": rid, - "br": "1", - } - payload = self._api_get("", params=params, host=self.parse_api, headers={"User-Agent": "LX-Music-Mobile"}) or {} - url = str(payload.get("url") or "") - if not url: - url = ( - f"{self.parse_api}?use_xbridge3=true&loader_name=forest&need_sec_link=1" - f"&sec_link_scene=im&theme=light&types=url&source=kuwo&id={rid}&br=1" - ) - return { - "parse": 0, - "url": url, - "header": {"User-Agent": "LX-Music-Mobile", "Referer": "https://music-api.gdstudio.xyz"}, - } - - def playerContent(self, flag, id, vipFlags): - play_id = str(id or "") - if play_id.startswith("free|"): - return self._resolve_free_play(play_id.split("|", 1)[1]) - if play_id.startswith("vip|"): - return self._resolve_vip_play(play_id.split("|", 1)[1]) - return {"parse": 0, "url": play_id, "header": {"User-Agent": self.ua}} diff --git a/py/酷我听书.txt b/py/酷我听书.txt new file mode 100644 index 0000000..782a9d8 --- /dev/null +++ b/py/酷我听书.txt @@ -0,0 +1,15 @@ +// ignore +//@name:酷我听书 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:4PG8rqYE58cLrzeQ +//@ek:base64:piWEvVO9qSnsgqaWIMyBAmnRWH5NFatPUJg9myQetdwwZ0isGDJT6tEA53/0Ykwb +//@hash:sha256:bcd719be6efcbfb8eb95ef2c6d466a9a865bc539e1dd0982120512876db71b6d +//@sig:base64:HvbFEqcg6EKvFV0+uSTHTcgndumJ1sxtC2UznCygwXp+gfDk4vq0Vb6zwHR8Pe7oVOauWSAlwLSPVMPs12HsCw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/金牌.py b/py/金牌.py deleted file mode 100644 index dbfd0b2..0000000 --- a/py/金牌.py +++ /dev/null @@ -1,243 +0,0 @@ -# coding=utf-8 -import hashlib -import json -import sys -import time - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "金牌" - self.host = "https://m.jiabaide.cn" - self.app_key = "cb808529bae6b6be45ecfab29a4889bc" - self.mobile_ua = ( - "Mozilla/5.0 (Linux; Android 11; Pixel 5) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/90.0.4430.91 Mobile Safari/537.36" - ) - self.headers = { - "User-Agent": self.mobile_ua, - "Referer": self.host + "/", - } - self.class_name_map = { - "typeList": ("type", "类型"), - "plotList": ("class", "剧情"), - "districtList": ("area", "地区"), - "languageList": ("lang", "语言"), - "yearList": ("year", "年份"), - "serialList": ("by", "排序"), - } - self.sort_values = [ - {"n": "最近更新", "v": "1"}, - {"n": "添加时间", "v": "2"}, - {"n": "人气高低", "v": "3"}, - {"n": "评分高低", "v": "4"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeVideoContent(self): - return {"list": []} - - def _obj_to_form(self, obj=None): - pairs = [] - for key, value in (obj or {}).items(): - if value in ("", None): - continue - pairs.append(f"{key}={value}") - return "&".join(pairs) - - def _signed_headers(self, params=None): - current = str(int(time.time() * 1000)) - sign_obj = dict(params or {}) - sign_obj["key"] = self.app_key - sign_obj["t"] = current - obj_str = self._obj_to_form(sign_obj) - md5_value = hashlib.md5(obj_str.encode("utf-8")).hexdigest() - sign = hashlib.sha1(md5_value.encode("utf-8")).hexdigest() - headers = dict(self.headers) - headers["t"] = current - headers["sign"] = sign - return headers - - def _fetch_json(self, path, params=None): - target = self.host + str(path) - query = self._obj_to_form(params or {}) - if query: - target = target + "?" + query - response = self.fetch(target, headers=self._signed_headers(params or {}), timeout=10, verify=False) - if response.status_code != 200: - return {} - try: - data = json.loads(response.text or "{}") - except Exception: - return {} - if str(data.get("code", "200")) not in ("200", "0", ""): - return {} - return data - - def _map_vod(self, item): - item = item or {} - pubdate = str(item.get("vodPubdate", "")).strip() - year = pubdate.split("-")[0] if pubdate else "" - remarks = [str(item.get("vodRemarks", "")).strip(), str(item.get("vodDoubanScore", "")).strip()] - return { - "vod_id": str(item.get("vodId", "")), - "vod_name": str(item.get("vodName", "")), - "vod_pic": str(item.get("vodPic", "")), - "vod_remarks": "_".join([value for value in remarks if value]), - "vod_year": year, - "type_id": str(item.get("typeId", "")), - "type_name": str(item.get("typeName", "")), - } - - def _build_filters(self): - classes = [] - filters = {} - type_res = self._fetch_json("/api/mw-movie/anonymous/get/filer/type") - for item in type_res.get("data", []): - classes.append( - { - "type_id": str(item.get("typeId", "")), - "type_name": str(item.get("typeName", "")), - } - ) - filter_res = self._fetch_json("/api/mw-movie/anonymous/v1/get/filer/list") - filter_data = filter_res.get("data", {}) - for cls in classes: - tid = cls["type_id"] - filters[tid] = [] - current = (filter_data or {}).get(tid, {}) - for raw_key, (key, name) in self.class_name_map.items(): - values = [{"n": "全部", "v": ""}] - if raw_key == "serialList": - values.extend(self.sort_values) - else: - for item in current.get(raw_key, []): - label = str(item.get("itemText", "")).strip() - if not label: - continue - value_key = "itemValue" if raw_key == "typeList" else "itemText" - values.append({"n": label, "v": str(item.get(value_key, "")).strip()}) - if len(values) > 1: - filters[tid].append({"key": key, "name": name, "value": values}) - return classes, filters - - def _page_result(self, items, pg, limit=30): - page = max(int(str(pg or 1)), 1) - return {"page": page, "limit": limit, "total": page * limit + len(items), "list": items} - - def homeContent(self, filter): - classes, filters = self._build_filters() - home = self._fetch_json("/api/mw-movie/anonymous/home/hotSearch") - return { - "class": classes, - "filters": filters, - "list": [self._map_vod(item) for item in home.get("data", [])], - } - - def categoryContent(self, tid, pg, filter, extend): - page = max(int(str(pg or 1)), 1) - values = dict(extend or {}) - payload = { - "area": str(values.get("area", "")), - "lang": str(values.get("lang", "")), - "pageNum": str(page), - "pageSize": "30", - "sort": str(values.get("by", "1")), - "sortBy": "1", - "type": str(values.get("type", "")), - "type1": str(tid), - "v_class": str(values.get("class", "")), - "year": str(values.get("year", "")), - } - result = self._fetch_json("/api/mw-movie/anonymous/video/list", payload) - items = [self._map_vod(item) for item in ((result.get("data") or {}).get("list") or [])] - return self._page_result(items, page, 30) - - def searchContent(self, key, quick, pg="1"): - page = max(int(str(pg or 1)), 1) - keyword = str(key or "").strip() - if not keyword: - return {"page": page, "limit": 30, "total": 0, "list": []} - result = self._fetch_json( - "/api/mw-movie/anonymous/video/searchByWordPageable", - {"keyword": keyword, "pageNum": str(page), "pageSize": "30"}, - ) - items = [self._map_vod(item) for item in ((result.get("data") or {}).get("list") or [])] - return self._page_result(items, page, 30) - - def _build_play_id(self, vod_id, nid): - return f"{str(vod_id).strip()}@{str(nid).strip()}" - - def _parse_play_id(self, value): - parts = str(value or "").split("@", 1) - if len(parts) != 2: - return {"id": "", "nid": ""} - sid = parts[0].strip() - nid = parts[1].strip() - if not sid or not nid: - return {"id": "", "nid": ""} - return {"id": sid, "nid": nid} - - def detailContent(self, ids): - vod_id = str(ids[0] if isinstance(ids, list) and ids else ids or "").strip() - if not vod_id: - return {"list": []} - result = self._fetch_json("/api/mw-movie/anonymous/video/detail", {"id": vod_id}) - data = result.get("data") or {} - if not data: - return {"list": []} - episodes = [] - for item in data.get("episodeList", []): - name = str(item.get("name", "")).strip() - nid = str(item.get("nid", "")).strip() - if not name or not nid: - continue - episodes.append(f"{name}${self._build_play_id(data.get('vodId', vod_id), nid)}") - vod = { - "vod_id": str(data.get("vodId", vod_id)), - "vod_name": str(data.get("vodName", "")), - "vod_pic": str(data.get("vodPic", "")), - "type_name": str(data.get("vodClass", "")), - "vod_remarks": str(data.get("vodRemarks", "")), - "vod_year": str(data.get("vodYear", "")), - "vod_area": str(data.get("vodArea", "")), - "vod_lang": str(data.get("vodLang", "")), - "vod_director": str(data.get("vodDirector", "")), - "vod_actor": str(data.get("vodActor", "")), - "vod_content": str(data.get("vodContent", "")), - "vod_play_from": "金牌线路" if episodes else "", - "vod_play_url": "#".join(episodes), - } - return {"list": [vod]} - - def playerContent(self, flag, id, vipFlags): - parsed = self._parse_play_id(id) - if not parsed["id"] or not parsed["nid"]: - return {"parse": 0, "playUrl": "", "url": "", "header": {}} - result = self._fetch_json( - "/api/mw-movie/anonymous/v2/video/episode/url", - {"clientType": "3", "id": parsed["id"], "nid": parsed["nid"]}, - ) - for item in ((result.get("data") or {}).get("list") or []): - url = str(item.get("url", "")).strip() - if url: - return { - "parse": 0, - "playUrl": "", - "url": url, - "header": {"User-Agent": self.mobile_ua}, - } - return {"parse": 0, "playUrl": "", "url": "", "header": {}} diff --git a/py/金牌.txt b/py/金牌.txt new file mode 100644 index 0000000..a6ff21b --- /dev/null +++ b/py/金牌.txt @@ -0,0 +1,15 @@ +// ignore +//@name:金牌 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:inxIpShqg/4kOpyB +//@ek:base64:ly/C7OSiyIShCKLrkXk/re8xCnfj5aPTvLfFe53Jwf+N+uWLHuKP5odE29rwu97Y +//@hash:sha256:c6cd359bace08a679f2b2a6ef990de00a2a5646951fee4024140aace0fd4ff41 +//@sig:base64:yvhnwCfwHITYKlu1xj4Qdu7zIUcAblRBsrFDYr21MKaCewvRa2kiBLe2jIxALKi60Es1lENJKngAQ0p4bUxyBA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/闪电.py b/py/闪电.py deleted file mode 100644 index a04c0eb..0000000 --- a/py/闪电.py +++ /dev/null @@ -1,255 +0,0 @@ -# coding=utf-8 -import re -import sys -from urllib.parse import quote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "闪电" - self.host = "https://sd.sduc.site" - self.headers = { - "User-Agent": ( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/136.0.0.0 Safari/537.36" - ), - "Referer": self.host + "/", - } - self.categories = [ - {"type_id": "1", "type_name": "闪电电影"}, - {"type_id": "2", "type_name": "闪电剧集"}, - {"type_id": "3", "type_name": "闪电综艺"}, - {"type_id": "4", "type_name": "闪电动漫"}, - {"type_id": "30", "type_name": "闪电短剧"}, - ] - self.pan_patterns = [ - ("baidu", "百度资源", r"pan\.baidu\.com|yun\.baidu\.com"), - ("a139", "139资源", r"yun\.139\.com"), - ("a189", "天翼资源", r"cloud\.189\.cn"), - ("a123", "123资源", r"123684\.com|123865\.com|123912\.com|123pan\.com"), - ("a115", "115资源", r"115\.com"), - ("quark", "夸克资源", r"pan\.quark\.cn"), - ("xunlei", "迅雷资源", r"pan\.xunlei\.com"), - ("aliyun", "阿里资源", r"aliyundrive\.com|alipan\.com"), - ("uc", "UC资源", r"drive\.uc\.cn"), - ] - self.pan_priority = { - "baidu": 1, - "a139": 2, - "a189": 3, - "a123": 4, - "a115": 5, - "quark": 6, - "xunlei": 7, - "aliyun": 8, - "uc": 9, - } - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.categories} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, path): - return urljoin(self.host + "/", str(path or "").strip()) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _detect_pan_type(self, url): - raw = str(url or "").strip() - for pan_type, title, pattern in self.pan_patterns: - if re.search(pattern, raw, re.I): - return pan_type, title - return "", "" - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=dict(self.headers), timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _page_result(self, items, pg): - page = int(pg) - return {"page": page, "limit": len(items), "total": page * 20 + len(items), "list": items} - - def _parse_cards(self, html): - root = self.html(html) - if root is None: - return [] - - items = [] - seen = set() - for node in root.xpath( - "//*[@id='main']//*[contains(concat(' ', normalize-space(@class), ' '), ' module-item ')]" - ): - href = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//a[@href])[1]/@href") or [""])[0]).strip() - title = ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@alt])[1]/@alt") or [""])[0]).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-text')])[1]//text()"))) - year = self._clean_text("".join(node.xpath("(.//*[contains(@class,'module-item-caption')])[1]//span[1]//text()"))) - if not href or not title or href in seen: - continue - seen.add(href) - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - "vod_year": year, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - url = self._build_url(f"/index.php/vod/show/id/{tid}/page/{int(pg)}.html") - return self._page_result(self._parse_cards(self._request_html(url)), pg) - - def searchContent(self, key, quick, pg="1"): - keyword = self._clean_text(key) - page = int(pg) - if not keyword: - return {"page": page, "total": 0, "list": []} - - url = self._build_url(f"/index.php/vod/search/page/{page}/wd/{quote(keyword)}.html") - root = self.html(self._request_html(url)) - if root is None: - return {"page": page, "total": 0, "list": []} - - items = [] - for node in root.xpath("//*[contains(@class,'module-search-item')]"): - href = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@href")).strip() - title = "".join(node.xpath(".//*[contains(@class,'video-serial')][1]/@title")).strip() - pic = ( - ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@data-src])[1]/@data-src") or [""])[0]).strip() - or ((node.xpath("(.//*[contains(@class,'module-item-pic')]//img[@src])[1]/@src") or [""])[0]).strip() - ) - remarks = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'video-serial')][1]//text()")) - or "".join(node.xpath(".//*[contains(@class,'module-item-text')][1]//text()")) - ) - if not href or not title: - continue - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return {"page": page, "total": len(items), "list": items} - - def _parse_detail_page(self, vod_id, html): - root = self.html(html) - if root is None: - return { - "vod_id": vod_id, - "vod_name": "", - "vod_pic": "", - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - detail = { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath("//*[contains(@class,'page-title')][1]//text()"))), - "vod_pic": self._build_url( - ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@data-src") or [""])[0] - ).strip() - or ( - (root.xpath("//*[contains(@class,'mobile-play')]//*[contains(@class,'lazyload')][1]/@src") or [""])[0] - ).strip() - ), - "vod_year": "", - "vod_director": "", - "vod_actor": "", - "vod_content": "", - "pan_urls": [], - } - - for label_node in root.xpath("//*[contains(@class,'video-info-itemtitle')]"): - key = self._clean_text("".join(label_node.xpath(".//text()"))) - sibling = label_node.getnext() - if sibling is None: - continue - values = [self._clean_text(text) for text in sibling.xpath(".//a//text()")] - joined = ",".join([value for value in values if value]) - text_value = self._clean_text("".join(sibling.xpath(".//text()"))) - if "年代" in key: - detail["vod_year"] = joined or text_value - elif "导演" in key: - detail["vod_director"] = joined or text_value - elif "主演" in key: - detail["vod_actor"] = joined or text_value - elif "剧情" in key: - detail["vod_content"] = text_value - - for node in root.xpath("//*[contains(@class,'module-row-info')]//p"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if text: - detail["pan_urls"].append(text) - return detail - - def _build_pan_lines(self, detail): - lines = [] - seen = set() - for url in detail.get("pan_urls", []): - pan_type, title = self._detect_pan_type(url) - if not pan_type or url in seen: - continue - seen.add(url) - lines.append((self.pan_priority.get(pan_type, 999), f"{pan_type}#闪电", f"{title}${url}")) - lines.sort(key=lambda item: item[0]) - return [(item[1], item[2]) for item in lines] - - def detailContent(self, ids): - result = {"list": []} - for raw_id in ids: - vod_id = str(raw_id or "").strip() - detail = self._parse_detail_page(vod_id, self._request_html(self._build_url(vod_id))) - lines = self._build_pan_lines(detail) - result["list"].append( - { - "vod_id": vod_id, - "vod_name": detail["vod_name"], - "vod_pic": detail["vod_pic"], - "vod_year": detail["vod_year"], - "vod_director": detail["vod_director"], - "vod_actor": detail["vod_actor"], - "vod_content": detail["vod_content"], - "vod_play_from": "$$$".join([item[0] for item in lines]), - "vod_play_url": "$$$".join([item[1] for item in lines]), - } - ) - return result - - def playerContent(self, flag, id, vipFlags): - pan_type, _ = self._detect_pan_type(id) - if pan_type: - return {"parse": 0, "playUrl": "", "url": id} - return {"parse": 0, "playUrl": "", "url": ""} diff --git a/py/闪电.txt b/py/闪电.txt new file mode 100644 index 0000000..3bfae08 --- /dev/null +++ b/py/闪电.txt @@ -0,0 +1,15 @@ +// ignore +//@name:闪电 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:rPuk0XitOZLnsFVE +//@ek:base64:ttihcV6SINwY3wHz3buUKEqjlUEPFzSX/RlfTK0XQPoCXkQZ1H//8bfl1ZnTwXHc +//@hash:sha256:bb76b4dffc5e804ae5d356b35c85ce7affa639d0449783119ff669a2f02f8313 +//@sig:base64:N7cV8/PREmDi9JzvNy4AV4v1HFlSEi80+/OTakQwf/SrC6nUtLciaQaAqSRKOVON0UdyzMm5FhxFNiFl0yUgBA== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/飞快TV.py b/py/飞快TV.py deleted file mode 100644 index c426386..0000000 --- a/py/飞快TV.py +++ /dev/null @@ -1,287 +0,0 @@ -# coding=utf-8 -import base64 -import json -import re -import sys -from urllib.parse import quote, unquote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "飞快TV" - self.host = "https://feikuai.tv" - self.user_agent = ( - "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/130.0.0.0 Safari/537.36" - ) - self.headers = { - "User-Agent": self.user_agent, - "Referer": self.host + "/", - "Origin": self.host, - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "剧集"}, - {"type_id": "3", "type_name": "综艺"}, - {"type_id": "4", "type_name": "动漫"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - return {"list": []} - - def _build_url(self, value): - raw = str(value or "").strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw) - - def _clean_text(self, text): - return re.sub(r"\s+", " ", str(text or "").replace("\xa0", " ")).strip() - - def _request_html(self, path_or_url): - target = path_or_url if str(path_or_url).startswith("http") else self._build_url(path_or_url) - response = self.fetch(target, headers=self.headers, timeout=10) - if response.status_code != 200: - return "" - return str(response.text or "") - - def _parse_category_cards(self, html): - root = self.html(html or "") - if root is None: - return [] - items = [] - for node in root.xpath("//a[contains(@class,'module-poster-item')]"): - vod_id = self._clean_text("".join(node.xpath("./@href"))) - vod_name = self._clean_text("".join(node.xpath("./@title"))) or self._clean_text( - "".join(node.xpath(".//*[contains(@class,'module-poster-item-title')][1]//text()")) - ) - vod_pic = self._clean_text( - "".join(node.xpath(".//img[contains(@class,'lazy')][1]/@data-original")) - ) - vod_remarks = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'module-item-note')][1]//text()")) - ) - if vod_id and vod_name: - items.append( - { - "vod_id": vod_id, - "vod_name": vod_name, - "vod_pic": self._build_url(vod_pic), - "vod_remarks": vod_remarks, - } - ) - return items - - def _parse_search_cards(self, html): - root = self.html(html or "") - if root is None: - return [] - items = [] - for node in root.xpath( - "//*[contains(@class,'module-card-item') and contains(@class,'module-item')]" - ): - vod_id = self._clean_text( - "".join(node.xpath(".//a[contains(@class,'module-card-item-poster')][1]/@href")) - ) - vod_name = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'module-card-item-title')][1]//strong/text()")) - ) - vod_pic = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'module-item-pic')]//img[1]/@data-original")) - ) - vod_remarks = self._clean_text( - "".join(node.xpath(".//*[contains(@class,'module-item-note')][1]//text()")) - ) - if vod_id and vod_name: - items.append( - { - "vod_id": vod_id, - "vod_name": vod_name, - "vod_pic": self._build_url(vod_pic), - "vod_remarks": vod_remarks, - } - ) - return items - - def _detect_pan_type(self, url): - value = str(url or "").strip() - if "pan.quark.cn" in value: - return "quark" - if "drive.uc.cn" in value: - return "uc" - if "alipan.com" in value or "aliyundrive.com" in value: - return "aliyun" - if "pan.baidu.com" in value: - return "baidu" - return "pan" - - def _join_group_urls(self, groups): - return "$$$".join("#".join(group) for group in groups if group) - - def _base64decode(self, value): - try: - return base64.b64decode(str(value or "")).decode("utf-8") - except Exception: - return "" - - def _extract_player_data(self, html): - body = str(html or "") - matched = re.search(r"player_aaaa\s*=\s*\{", body) - if not matched: - return {} - start = matched.end() - 1 - depth = 0 - in_string = False - escape = False - end = -1 - for index in range(start, len(body)): - char = body[index] - if in_string: - if escape: - escape = False - elif char == "\\": - escape = True - elif char == '"': - in_string = False - continue - if char == '"': - in_string = True - continue - if char == "{": - depth += 1 - continue - if char == "}": - depth -= 1 - if depth == 0: - end = index + 1 - break - if end < 0: - return {} - try: - return json.loads(body[start:end]) - except Exception: - return {} - - def categoryContent(self, tid, pg, filter, extend): - page = max(1, int(pg)) - url = self.host + f"/vodshow/{tid}--------{page}---.html" - items = self._parse_category_cards(self._request_html(url)) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = max(1, int(pg)) - keyword = self._clean_text(key) - if not keyword: - return {"page": page, "limit": 0, "total": 0, "list": []} - url = self.host + "/label/search_ajax.html?wd=" + quote(keyword) + f"&by=time&order=desc&page={page}" - items = self._parse_search_cards(self._request_html(url)) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def detailContent(self, ids): - vod_id = str(ids[0] if isinstance(ids, list) and ids else ids or "").strip() - if not vod_id: - return {"list": []} - html = self._request_html(self.host + vod_id) - root = self.html(html or "") - if root is None: - return {"list": []} - - title = self._clean_text("".join(root.xpath("//h1[1]//text()"))) - pic = self._clean_text( - "".join(root.xpath("//*[contains(@class,'module-item-pic')]//img[1]/@data-original")) - ) - content = self._clean_text( - "".join(root.xpath("//*[contains(@class,'module-info-introduction-content')][1]//text()")) - ) - - play_from = [] - play_urls = [] - online_names = [ - self._clean_text("".join(node.xpath(".//text()"))) - for node in root.xpath( - "//div[contains(@class,'module-tab-items-box')]/*[contains(@class,'module-tab-item')][not(@onclick)]" - ) - ] - online_lists = root.xpath( - "//div[contains(@class,'module-list') and contains(@class,'tab-list')][not(contains(@class,'module-downlist'))]" - ) - for index, node in enumerate(online_lists): - episodes = [] - for item in node.xpath(".//a[contains(@class,'module-play-list-link')]"): - name = self._clean_text("".join(item.xpath(".//text()"))) - href = self._clean_text("".join(item.xpath("./@href"))) - if name and href: - episodes.append(f"{name}${href}") - if episodes: - group_name = online_names[index] if index < len(online_names) and online_names[index] else f"线路{index + 1}" - play_from.append(group_name) - play_urls.append(episodes) - - pan_groups = {} - for node in root.xpath("//div[contains(@class,'module-list')]/*[contains(@class,'tab-content')]"): - raw_name = self._clean_text("".join(node.xpath(".//h4[1]//text()"))) - pan_name = raw_name.split("@", 1)[0].strip() if raw_name else "网盘资源" - pan_url = self._clean_text("".join(node.xpath(".//p[1]//text()"))) - if not pan_url.startswith("http"): - continue - pan_type = self._detect_pan_type(pan_url) - pan_groups.setdefault(pan_type, []).append(f"{pan_name}${pan_url}") - - for key, values in pan_groups.items(): - play_from.append(key) - play_urls.append(values) - - vod = { - "vod_id": vod_id, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_content": content, - "vod_remarks": "", - "vod_play_from": "$$$".join(play_from), - "vod_play_url": self._join_group_urls(play_urls), - } - return {"list": [vod]} - - def playerContent(self, flag, id, vipFlags): - raw_id = str(id or "") - if raw_id.startswith(("http://", "https://")) and any( - raw_id.lower().split("?")[0].endswith(ext) for ext in [".m3u8", ".mp4", ".flv"] - ): - return {"parse": 0, "jx": 0, "url": raw_id} - - target = self.host + raw_id - data = self._extract_player_data(self._request_html(target)) - raw_url = str(data.get("url") or "") - encrypt = str(data.get("encrypt") or "") - media_url = "" - if encrypt == "1": - media_url = unquote(raw_url) - elif encrypt == "2": - media_url = unquote(self._base64decode(raw_url)) - elif raw_url: - media_url = raw_url - - if media_url.startswith("http"): - return {"parse": 0, "jx": 0, "url": media_url} - return {"parse": 1, "jx": 1, "url": target} diff --git a/py/飞快TV.txt b/py/飞快TV.txt new file mode 100644 index 0000000..69bfa07 --- /dev/null +++ b/py/飞快TV.txt @@ -0,0 +1,15 @@ +// ignore +//@name:飞快TV +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:WLdHc86EyZBqUVJq +//@ek:base64:j/mpRv3TzYX54CerHAQNa0RQE3G+w7+qGHp3OwWXRZp7QnJO+jPS3QCzMsfJG7BC +//@hash:sha256:660cb263f8bdc68c23178518711e3d5450c66e69140f3c360679baaf661ab4ca +//@sig:base64:IjpeZzcVgRWxRIwdiPX0I7btjwXtxYigGwtTilWIaGE5438oNgQlQ16w7H4pfH83OPs0Ii+pl3yUTIBsRuvaCw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/魔方APP.py b/py/魔方APP.py deleted file mode 100644 index 2401300..0000000 --- a/py/魔方APP.py +++ /dev/null @@ -1,413 +0,0 @@ -# coding=utf-8 -import base64 -import json -import sys -import uuid -from datetime import datetime -from urllib.parse import unquote - -try: - from Crypto.Cipher import AES - from Crypto.Util.Padding import pad, unpad -except ModuleNotFoundError: - from Cryptodome.Cipher import AES - from Cryptodome.Util.Padding import pad, unpad - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "魔方APP" - self.host = "http://www.613mf4k12.top" - self.api_path = "/api.php/getappapi" - self.user_agent = "okhttp/3.10.0" - self.aes_key = "1234567887654321" - self.aes_iv = "1234567887654321" - self.category_config = { - "blockedNames": ["全部"], - "renameMap": {}, - "forceOrder": ["电影", "连续剧", "综艺", "动漫", "短剧", "直播"], - } - self.area_merge_config = { - "enabled": True, - "displayName": "大陆", - "mergeList": ["中国大陆", "大陆", "内地"], - } - self.ocr_api = "http://154.222.22.188:9898/ocr/b64/text" - self.line_config = { - "4K线路db4": {"displayName": "🌷4K高清1", "order": 101, "mode": "direct", "enabled": True}, - "4K线路3U": {"displayName": "🌷4K高清2", "order": 102, "mode": "direct", "enabled": True}, - "4K极清": {"displayName": "🌷4K高清3", "order": 103, "mode": "direct", "enabled": True}, - "4K线路": {"displayName": "🌷4K高清4", "order": 104, "mode": "direct", "enabled": True}, - "腾讯视频": {"displayName": "⭐️腾讯视频", "order": 201, "mode": "direct", "enabled": True}, - "芒果视频": {"displayName": "⭐️芒果视频", "order": 202, "mode": "direct", "enabled": True}, - "奇艺视频": {"displayName": "⭐️奇艺视频", "order": 203, "mode": "direct", "enabled": True}, - "优酷视频": {"displayName": "⭐️优酷视频", "order": 204, "mode": "direct", "enabled": True}, - "电影天堂": {"displayName": "❤️电影天堂", "order": 301, "mode": "direct", "enabled": True}, - "如意资源": {"displayName": "❤️如意资源", "order": 306, "mode": "direct", "enabled": True}, - "红牛在线": {"displayName": "❤️红牛在线", "order": 303, "mode": "direct", "enabled": True}, - "豆瓣在线": {"displayName": "❤️豆瓣在线", "order": 304, "mode": "direct", "enabled": True}, - "暴风资源": {"displayName": "❤️暴风资源", "order": 305, "mode": "direct", "enabled": True}, - "极速资源": {"displayName": "❤️极速资源", "order": 307, "mode": "direct", "enabled": True}, - "茅台资源": {"displayName": "❤️茅台资源", "order": 308, "mode": "direct", "enabled": True}, - "水印资源": {"displayName": "❤️水印资源", "order": 309, "mode": "direct", "enabled": False}, - "无尽": {"displayName": "❤️无尽资源", "order": 310, "mode": "direct", "enabled": True}, - "YY": {"displayName": "❤️YY资源", "order": 311, "mode": "direct", "enabled": False}, - } - - def init(self, extend=""): - self.init_api = "initV119" - self.search_api = "searchList" - self.search_verify = False - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def homeVideoContent(self): - return {"list": []} - - def _build_api_url(self, endpoint): - path = str(endpoint or "").lstrip("/") - return f"{self.host}{self.api_path}.index/{path}" - - def _headers(self): - return { - "User-Agent": self.user_agent, - "Accept-Encoding": "gzip", - } - - def _aes_encrypt(self, text): - cipher = AES.new(self.aes_key.encode("utf-8"), AES.MODE_CBC, self.aes_iv.encode("utf-8")) - return base64.b64encode(cipher.encrypt(pad(str(text).encode("utf-8"), AES.block_size))).decode("utf-8") - - def _aes_decrypt(self, text): - cipher = AES.new(self.aes_key.encode("utf-8"), AES.MODE_CBC, self.aes_iv.encode("utf-8")) - return unpad(cipher.decrypt(base64.b64decode(str(text or ""))), AES.block_size).decode("utf-8") - - def _replace_code(self, text): - replacements = { - "y": "9", - "口": "0", - "q": "0", - "u": "0", - "o": "0", - ">": "1", - "d": "0", - "b": "8", - "已": "2", - "D": "0", - "五": "5", - } - return "".join(replacements.get(char, char) for char in str(text or "")) - - def _api_post(self, endpoint, payload=None): - data = {} if payload is None else dict(payload) - response = self.post( - self._build_api_url(endpoint), - data=data, - headers=self._headers(), - timeout=10, - verify=False, - ) - try: - body = json.loads(response.text or "{}") - except (json.JSONDecodeError, TypeError): - return None - if not body.get("data"): - return None - return json.loads(self._aes_decrypt(body["data"])) - - def _process_classes(self, type_list): - blocked = set(self.category_config.get("blockedNames", [])) - rename_map = self.category_config.get("renameMap", {}) - order_map = {name: index for index, name in enumerate(self.category_config.get("forceOrder", []))} - classes = [ - { - "type_id": item.get("type_id", ""), - "type_name": rename_map.get(item.get("type_name", ""), item.get("type_name", "")), - } - for item in type_list - if item.get("type_name") not in blocked - ] - classes.sort(key=lambda item: order_map.get(item["type_name"], 999)) - return classes - - def _merge_area_filter(self, values): - merge_values = set(self.area_merge_config.get("mergeList", [])) - raw_values = list(values) - if not self.area_merge_config.get("enabled") or not any(value in merge_values for value in raw_values): - return raw_values - result = [value for value in raw_values if value not in merge_values] - index = result.index("全部") + 1 if "全部" in result else 0 - result.insert(index, self.area_merge_config.get("displayName", "大陆")) - return result - - def _convert_filters(self, type_list): - name_map = {"class": "类型", "area": "地区", "lang": "语言", "year": "年份", "sort": "排序"} - current_year = str(datetime.now().year) - filters = {} - for item in type_list: - entries = [] - for config in item.get("filter_type_list", []): - raw_name = config.get("name", "") - values = list(config.get("list", [])) - if raw_name == "area": - values = self._merge_area_filter(values) - if raw_name == "year" and current_year not in values: - index = values.index("全部") + 1 if "全部" in values else 0 - values.insert(index, current_year) - entries.append( - { - "key": "by" if raw_name == "sort" else raw_name, - "name": name_map.get(raw_name, raw_name), - "value": [{"n": value, "v": value} for value in values], - } - ) - filters[item.get("type_id", "")] = entries - return filters - - def homeContent(self, filter): - init_data = self._api_post(self.init_api) or {"type_list": [], "config": {}} - self.search_verify = bool(init_data.get("config", {}).get("system_search_verify_status")) - return { - "class": self._process_classes(init_data.get("type_list", [])), - "filters": self._convert_filters(init_data.get("type_list", [])), - "list": [vod for item in init_data.get("type_list", []) for vod in item.get("recommend_list", [])], - } - - def _page_result(self, items, pg, limit=90, total=None): - page = int(pg) - return { - "page": page, - "limit": limit, - "total": len(items) if total is None else total, - "list": items, - } - - def _merge_area_search(self, tid, pg, extend): - seen = set() - merged = [] - for area in self.area_merge_config.get("mergeList", []): - payload = { - "type_id": str(tid), - "page": str(pg), - "area": area, - "year": extend.get("year", "全部"), - "sort": extend.get("by", "最新"), - "lang": extend.get("lang", "全部"), - "class": extend.get("class", "全部"), - } - result = self._api_post("typeFilterVodList", payload) or {} - for item in result.get("recommend_list", []): - vod_id = item.get("vod_id") - if vod_id in seen: - continue - seen.add(vod_id) - merged.append(item) - return merged - - def categoryContent(self, tid, pg, filter, extend): - options = dict(extend or {}) - if options.get("area") == self.area_merge_config.get("displayName"): - return self._page_result(self._merge_area_search(tid, pg, options), pg) - payload = { - "type_id": str(tid), - "page": str(pg), - "area": options.get("area", "全部"), - "year": options.get("year", "全部"), - "sort": options.get("by", "最新"), - "lang": options.get("lang", "全部"), - "class": options.get("class", "全部"), - } - result = self._api_post("typeFilterVodList", payload) or {} - return self._page_result(result.get("recommend_list", []), pg) - - def _get_verification_code(self): - uuid_value = str(uuid.uuid4()) - image_response = self.fetch( - f"{self.host}{self.api_path}.index/verify/create?key={uuid_value}", - headers={"User-Agent": self.user_agent}, - timeout=10, - verify=False, - ) - image_b64 = base64.b64encode(image_response.content).decode("utf-8") - ocr_response = self.fetch( - self.ocr_api, - data=image_b64, - headers={"User-Agent": self.user_agent, "Content-Type": "text/plain"}, - timeout=10, - verify=False, - ) - code = self._replace_code(getattr(ocr_response, "text", "")) - if len(code) == 3: - code = code.replace("566", "5066").replace("066", "1666") - if not code.isdigit() or len(code) != 4: - return None - return {"uuid": uuid_value, "code": code} - - def searchContent(self, key, quick, pg="1"): - if self.search_verify: - verify = self._get_verification_code() - if not verify: - return { - "page": int(pg), - "limit": 90, - "total": 0, - "list": [], - "msg": "验证码获取失败", - } - result = self._api_post( - self.search_api, - {"keywords": str(key or ""), "type_id": "0", "page": str(pg)}, - ) or {} - keyword = str(key or "").strip().lower() - items = [] - for item in result.get("search_list", []): - vod_class = str(item.get("vod_class", "")) - text = " ".join( - [str(item.get("vod_name", "")), str(item.get("vod_remarks", "")), vod_class] - ).lower() - if "屏蔽预留" in vod_class: - continue - if keyword and keyword not in text: - continue - items.append( - { - "vod_id": item.get("vod_id", ""), - "vod_name": item.get("vod_name", ""), - "vod_pic": item.get("vod_pic", ""), - "vod_remarks": " ".join( - value for value in [str(item.get("vod_year", "")), vod_class] if value - ).strip(), - } - ) - return self._page_result(items, pg) - - def _get_line_config(self, name): - for key, value in self.line_config.items(): - if key in str(name or ""): - return value - return None - - def _line_display(self, name): - config = self._get_line_config(name) - return config.get("displayName", name) if config else name - - def _line_order(self, name): - config = self._get_line_config(name) - return config.get("order", 999) if config else 999 - - def _line_mode(self, name): - config = self._get_line_config(name) - return config.get("mode", "direct") if config else "direct" - - def _line_blocked(self, name): - config = self._get_line_config(name) - return bool(config) and config.get("enabled") is False - - def _player_headers(self): - return {"User-Agent": "Dalvik/2.1.0 (Linux; Android 14)"} - - def detailContent(self, ids): - items = [] - for vod_id in ids: - payload = {"vod_id": str(vod_id)} - data = self._api_post("vodDetail", payload) or self._api_post("vodDetail2", payload) - if not data: - continue - lines = [] - name_count = {} - fallback_index = 1 - for line in data.get("vod_play_list", []): - player_info = line.get("player_info", {}) - raw_name = str(player_info.get("show", "")) - if any(keyword in raw_name for keyword in ["防走丢", "群", "防失群", "官网"]): - raw_name = f"{fallback_index}线" - fallback_index += 1 - name_count[raw_name] = name_count.get(raw_name, 0) + 1 - line_name = raw_name if name_count[raw_name] == 1 else f"{raw_name}{name_count[raw_name]}" - if self._line_blocked(line_name): - continue - play_items = [] - for episode in line.get("urls", []): - payload_text = ",".join( - [ - str(player_info.get("parse", "")), - str(episode.get("url", "")), - "token+" + str(episode.get("token", "")), - str(player_info.get("player_parse_type", "")), - str(player_info.get("parse_type", "")), - ] - ) - play_items.append( - f"{episode.get('name', '')}${line_name}@@{self._line_mode(line_name)}@@{payload_text}" - ) - if play_items: - lines.append( - { - "display": self._line_display(line_name), - "order": self._line_order(line_name), - "urls": "#".join(play_items), - } - ) - lines.sort(key=lambda item: item["order"]) - vod = data.get("vod", {}) - items.append( - { - "vod_id": str(vod_id), - "vod_name": vod.get("vod_name", ""), - "vod_pic": vod.get("vod_pic", ""), - "vod_remarks": vod.get("vod_remarks", ""), - "vod_content": vod.get("vod_content", ""), - "vod_actor": str(vod.get("vod_actor", "")).replace("演员", ""), - "vod_director": str(vod.get("vod_director", "")).replace("导演", ""), - "vod_year": f"{vod.get('vod_year', '')}年" if vod.get("vod_year") else "", - "vod_area": vod.get("vod_area", ""), - "vod_play_from": "$$$".join(line["display"] for line in lines), - "vod_play_url": "$$$".join(line["urls"] for line in lines), - } - ) - return {"list": items} - - def playerContent(self, flag, id, vipFlags): - parts = str(id or "").split("@@", 2) - line_name = parts[0] if len(parts) > 0 else "" - mode = parts[1] if len(parts) > 1 else "direct" - payload = parts[2] if len(parts) > 2 else "" - if self._line_blocked(line_name): - return {"parse": 0, "jx": 0, "url": "", "header": {}} - if mode != "direct": - return {"parse": 0, "jx": 0, "url": "", "header": {}} - fields = payload.split(",", 4) - while len(fields) < 5: - fields.append("") - parse_api, play_url, token_with_prefix, player_parse_type, parse_type = fields - real_url = unquote(play_url) - token = token_with_prefix.replace("token+", "", 1) - if parse_type == "0": - return {"parse": 0, "jx": 0, "url": real_url, "header": self._player_headers()} - if parse_type == "2": - return {"parse": 1, "jx": 1, "url": parse_api + real_url, "header": self._player_headers()} - if player_parse_type == "2": - response = self.fetch(parse_api + real_url, headers=self._headers(), timeout=10, verify=False) - direct = json.loads(response.text or "{}") - if direct.get("url"): - return {"parse": 0, "jx": 0, "url": direct["url"], "header": {}} - result = self._api_post( - "vodParse", - { - "parse_api": parse_api, - "url": self._aes_encrypt(real_url), - "player_parse_type": player_parse_type, - "token": token, - }, - ) or {} - inner = json.loads(result.get("json", "{}")) - return {"parse": 0, "jx": 0, "url": inner.get("url", ""), "header": {}} diff --git a/py/魔方APP.txt b/py/魔方APP.txt new file mode 100644 index 0000000..8e3581e --- /dev/null +++ b/py/魔方APP.txt @@ -0,0 +1,15 @@ +// ignore +//@name:魔方APP +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:CQZ25JBPYyEdj+Wl +//@ek:base64:LrrZsawvRJu7+NzKOYelJxYkGkhm9pfntLH51d7mIlnfY85ycDQSnnY1hg8AWeXQ +//@hash:sha256:40bafe3183b4fb65eb4d711c0a9e97b499fd76175cca3b6183ccbfcc93212d29 +//@sig:base64:jqam7M+1ubtK/cZivV1ueR8QVvZLA/SEDNG8He0yTG3SV27TjPBqdEhShPe9FddPBPaU8/78ccmnsqXOdUlmBg== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/麦田影院.py b/py/麦田影院.py deleted file mode 100644 index 4740c62..0000000 --- a/py/麦田影院.py +++ /dev/null @@ -1,258 +0,0 @@ -# coding=utf-8 -import json -import re -import sys -from urllib.parse import unquote, urljoin - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "麦田影院" - self.host = "https://www.mtyy5.com" - self.user_agent = ( - "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " - "AppleWebKit/537.36 (KHTML, like Gecko) " - "Chrome/130.0.0.0 Safari/537.36" - ) - self.headers = { - "User-Agent": self.user_agent, - "Referer": self.host + "/", - "Origin": self.host, - } - self.classes = [ - {"type_id": "1", "type_name": "电影"}, - {"type_id": "2", "type_name": "电视剧"}, - {"type_id": "4", "type_name": "动漫"}, - {"type_id": "3", "type_name": "综艺"}, - {"type_id": "26", "type_name": "短剧"}, - {"type_id": "25", "type_name": "少儿"}, - ] - - def init(self, extend=""): - return None - - def getName(self): - return self.name - - def homeContent(self, filter): - return {"class": self.classes} - - def homeVideoContent(self): - return {"list": []} - - def _stringify(self, value): - return "" if value is None else str(value) - - def _clean_text(self, text): - raw = self._stringify(text).replace(" ", " ").replace("\xa0", " ") - return re.sub(r"\s+", " ", raw).strip() - - def _build_url(self, value): - raw = self._stringify(value).strip() - if not raw: - return "" - if raw.startswith(("http://", "https://")): - return raw - if raw.startswith("//"): - return "https:" + raw - return urljoin(self.host + "/", raw) - - def _request_html(self, path_or_url, referer=None): - target = path_or_url if self._stringify(path_or_url).startswith("http") else self._build_url(path_or_url) - headers = dict(self.headers) - headers["Referer"] = referer or self.headers["Referer"] - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return "" - return response.text or "" - - def _parse_cards(self, html): - root = self.html(self._stringify(html)) - if root is None: - return [] - items = [] - for node in root.xpath("//div[contains(@class,'public-list-box')]"): - href = self._clean_text("".join(node.xpath(".//a[contains(@class,'public-list-exp')][1]/@href"))) - title = self._clean_text("".join(node.xpath(".//a[contains(@class,'public-list-exp')][1]/@title"))) - pic = self._clean_text( - "".join(node.xpath(".//a[contains(@class,'public-list-exp')]//img[1]/@data-src")) - ) or self._clean_text( - "".join(node.xpath(".//a[contains(@class,'public-list-exp')]//img[1]/@src")) - ) - remarks = self._clean_text("".join(node.xpath(".//*[contains(@class,'public-list-prb')][1]//text()"))) - if href and title: - items.append( - { - "vod_id": href, - "vod_name": title, - "vod_pic": self._build_url(pic), - "vod_remarks": remarks, - } - ) - return items - - def categoryContent(self, tid, pg, filter, extend): - page = max(int(self._stringify(pg) or "1"), 1) - url = self.host + f"/vodshow/{tid}--------{page}---.html" - items = self._parse_cards(self._request_html(url)) - return {"page": page, "limit": len(items), "total": len(items), "list": items} - - def searchContent(self, key, quick, pg="1"): - page = max(int(self._stringify(pg) or "1"), 1) - return {"page": page, "limit": 0, "total": 0, "list": []} - - def _extract_detail_pic(self, root): - return self._clean_text( - "".join(root.xpath("//*[contains(@class,'detail-pic') or contains(@class,'vod-img')]//img[1]/@data-src")) - ) or self._clean_text( - "".join(root.xpath("//*[contains(@class,'detail-pic') or contains(@class,'vod-img')]//img[1]/@src")) - ) - - def _extract_detail_content(self, root): - candidates = [ - "//*[@id='height_limit'][1]", - "//*[contains(@class,'vod_content')][1]", - "//*[contains(@class,'detail-content')][1]", - "//*[contains(@class,'switch-box')]//*[contains(@class,'text') or contains(@class,'desc') or contains(@class,'content')][1]", - ] - for xpath in candidates: - nodes = root.xpath(xpath) - if not nodes: - continue - text = self._clean_text("".join(nodes[0].xpath(".//text()"))) - if text: - return text - return "" - - def _parse_meta_by_labels(self, root, labels): - if root is None: - return "" - values = labels if isinstance(labels, (list, tuple)) else [labels] - patterns = [str(item or "").rstrip(":：").strip() for item in values if str(item or "").strip()] - for node in root.xpath("//li|//p|//span|//div"): - text = self._clean_text("".join(node.xpath(".//text()"))) - if not text: - continue - for label in patterns: - matched = re.match(rf"^{re.escape(label)}\s*[:：]?\s*(.*)$", text) - if matched: - return self._clean_text(matched.group(1)) - return "" - - def _parse_play_groups(self, root): - names = [] - for node in root.xpath("//a[contains(@class,'swiper-slide')]"): - label = re.sub(r"\d", "", self._clean_text("".join(node.xpath(".//text()")))).strip() - names.append(label) - - groups = [] - for index, box in enumerate(root.xpath("//div[contains(@class,'anthology-list-box')]")): - episodes = [] - for item in box.xpath(".//ul[contains(@class,'anthology-list-play')]/li"): - name = self._clean_text("".join(item.xpath(".//text()"))) - href = self._clean_text("".join(item.xpath("./*[1]/@href"))) - if name and href: - episodes.append(f"{name}${href}") - if episodes: - title = names[index] if index < len(names) and names[index] else f"线路{index + 1}" - groups.append((title, "#".join(episodes))) - return groups - - def detailContent(self, ids): - vod_id = self._clean_text(ids[0] if isinstance(ids, list) and ids else ids) - if not vod_id: - return {"list": []} - root = self.html(self._request_html(self.host + vod_id)) - if root is None: - return {"list": []} - groups = self._parse_play_groups(root) - vod = { - "vod_id": vod_id, - "vod_name": self._clean_text("".join(root.xpath("//h1[1]//text()"))), - "vod_pic": self._build_url(self._extract_detail_pic(root)), - "type_name": self._parse_meta_by_labels(root, ["类型"]), - "vod_year": self._parse_meta_by_labels(root, ["年份", "年代"]), - "vod_area": self._parse_meta_by_labels(root, ["地区"]), - "vod_lang": self._parse_meta_by_labels(root, ["语言"]), - "vod_douban_score": self._parse_meta_by_labels(root, ["豆瓣", "评分"]), - "vod_douban_id": self._parse_meta_by_labels(root, ["豆瓣ID"]), - "vod_director": self._parse_meta_by_labels(root, ["导演"]), - "vod_actor": self._parse_meta_by_labels(root, ["主演", "演员"]), - "vod_content": self._extract_detail_content(root), - "vod_remarks": self._parse_meta_by_labels(root, ["状态", "备注", "更新"]), - "vod_play_from": "$$$".join(item[0] for item in groups), - "vod_play_url": "$$$".join(item[1] for item in groups), - } - return {"list": [vod]} - - def _request_json(self, url, referer=None): - target = self._build_url(url) - headers = dict(self.headers) - headers["Referer"] = referer or self.headers["Referer"] - response = self.fetch(target, headers=headers, timeout=10) - if response.status_code != 200: - return {} - try: - return json.loads(response.text or "") - except Exception: - return {} - - def _build_player_headers(self, referer): - return {"User-Agent": self.user_agent, "Referer": referer} - - def _extract_player_data(self, html): - matched = re.search(r"player_data\s*=\s*(\{.*?\})\s*", self._stringify(html), re.S) - if not matched: - return {} - try: - return json.loads(matched.group(1)) - except Exception: - return {} - - def playerContent(self, flag, id, vipFlags): - play_id = self._clean_text(id) - play_url = self.host + play_id if play_id.startswith("/") else self._build_url(play_id) - player_data = self._extract_player_data(self._request_html(play_url, referer=self.host + "/")) - direct_url = self._clean_text(player_data.get("url")) - if direct_url.startswith(("http://", "https://")): - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": direct_url, - "header": self._build_player_headers(play_url), - } - - decoded = unquote(direct_url) - if decoded: - signed = self._request_json( - self.host + f"/static/player/art.php?get_signed_url=1&url={decoded}", - referer=play_url, - ) - signed_url = self._clean_text(signed.get("signed_url")) - if signed_url: - final_data = self._request_json( - self.host + f"/static/player/art.php{signed_url}", - referer=play_url, - ) - final_url = self._clean_text(final_data.get("jmurl")) - if final_url: - return { - "parse": 0, - "jx": 0, - "playUrl": "", - "url": final_url, - "header": self._build_player_headers(play_url), - } - - return { - "parse": 1, - "jx": 1, - "playUrl": "", - "url": play_url, - "header": self._build_player_headers(play_url), - } diff --git a/py/麦田影院.txt b/py/麦田影院.txt new file mode 100644 index 0000000..42a09e0 --- /dev/null +++ b/py/麦田影院.txt @@ -0,0 +1,15 @@ +// ignore +//@name:麦田影院 +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:rtGtOFv6ZU+zHX+T +//@ek:base64:/0a1K+rOhxnUoJyr0B8VI5OlCQerHLsZ+gQMK4eb8yvYCAxrkZjPnjQ/ULxdbwE3 +//@hash:sha256:8e54bfc3335a026434c4409a98e48ef8dc121749f8e35b12cb663443ee387cc3 +//@sig:base64:uFfCc5VGbRAh1tYWtUCQKvqT4JZJbseQBUIx06sISH260sYnOJX+gR0nfi2Bw+grz81Am9PN+6fbULYJSzk4Dw== +// ignore +payload.base64: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 \ No newline at end of file diff --git a/py/黑猫APP.py b/py/黑猫APP.py deleted file mode 100644 index a294a27..0000000 --- a/py/黑猫APP.py +++ /dev/null @@ -1,362 +0,0 @@ -# coding=utf-8 -import base64 -import json -import sys -from datetime import datetime -from urllib.parse import unquote - -from Crypto.Cipher import AES -from Crypto.Util.Padding import pad, unpad - -from base.spider import Spider as BaseSpider - -sys.path.append("..") - - -class Spider(BaseSpider): - def __init__(self): - self.name = "黑猫APP" - self.host = "http://app1-0-0.87333.cc" - self.api_path = "/api.php/getappapi" - self.user_agent = "okhttp/3.10.0" - self.aes_key = "VwsHxkCViDXEExWa" - self.aes_iv = "VwsHxkCViDXEExWa" - self.category_config = { - "blockedNames": ["伦理"], - "renameMap": {}, - "forceOrder": ["电影", "连续剧", "综艺", "动漫", "短剧", "直播"], - } - self.area_merge_config = { - "enabled": True, - "displayName": "大陆", - "mergeList": ["中国大陆", "大陆", "内地"], - } - self.line_config = { - "高清线路1": {"displayName": "🐈‍⬛高清线路", "order": 301, "mode": "direct", "enabled": True}, - "标清线路2": {"displayName": "🐈‍⬛标清线路1", "order": 302, "mode": "direct", "enabled": True}, - "标清线路3": {"displayName": "🐈‍⬛标清线路2", "order": 303, "mode": "direct", "enabled": True}, - } - - def init(self, extend=""): - self.search_api = "searchList" - self.init_api = "initV119" - self.search_verify = False - return None - - def getName(self): - return self.name - - def danmaku(self): - return True - - def _headers(self): - return { - "User-Agent": self.user_agent, - "Accept-Encoding": "gzip", - } - - def homeVideoContent(self): - return {"list": []} - - def _build_api_url(self, endpoint): - path = str(endpoint or "").lstrip("/") - return f"{self.host}{self.api_path}.index/{path}" - - def _api_post(self, endpoint, payload=None): - data = {} if payload is None else dict(payload) - response = self.post( - self._build_api_url(endpoint), - data=data, - headers=self._headers(), - timeout=10, - verify=False, - ) - body = json.loads(response.text or "{}") - if not body.get("data"): - return None - return json.loads(self._aes_decrypt(body["data"])) - - def _aes_encrypt(self, text): - cipher = AES.new(self.aes_key.encode("utf-8"), AES.MODE_CBC, self.aes_iv.encode("utf-8")) - data = pad(str(text).encode("utf-8"), AES.block_size) - return base64.b64encode(cipher.encrypt(data)).decode("utf-8") - - def _aes_decrypt(self, text): - data = base64.b64decode(str(text or "")) - cipher = AES.new(self.aes_key.encode("utf-8"), AES.MODE_CBC, self.aes_iv.encode("utf-8")) - return unpad(cipher.decrypt(data), AES.block_size).decode("utf-8") - - def _replace_code(self, text): - replacements = { - "y": "9", - "口": "0", - "q": "0", - "u": "0", - "o": "0", - ">": "1", - "d": "0", - "b": "8", - "已": "2", - "D": "0", - "五": "5", - } - return "".join(replacements.get(char, char) for char in str(text or "")) - - def _process_classes(self, type_list): - blocked = set(self.category_config.get("blockedNames", [])) - rename_map = self.category_config.get("renameMap", {}) - order_map = {name: index for index, name in enumerate(self.category_config.get("forceOrder", []))} - classes = [ - { - "type_id": item.get("type_id", ""), - "type_name": rename_map.get(item.get("type_name", ""), item.get("type_name", "")), - } - for item in type_list - if item.get("type_name") not in blocked - ] - classes.sort(key=lambda item: order_map.get(item["type_name"], 999)) - return classes - - def _merge_area_filter(self, values): - merge_values = set(self.area_merge_config.get("mergeList", [])) - raw_values = list(values) - if not self.area_merge_config.get("enabled") or not any(value in merge_values for value in raw_values): - return raw_values - result = [value for value in raw_values if value not in merge_values] - index = result.index("全部") + 1 if "全部" in result else 0 - result.insert(index, self.area_merge_config.get("displayName", "大陆")) - return result - - def _convert_filters(self, type_list): - name_map = {"class": "类型", "area": "地区", "lang": "语言", "year": "年份", "sort": "排序"} - current_year = str(datetime.now().year) - filters = {} - for item in type_list: - entries = [] - for config in item.get("filter_type_list", []): - raw_name = config.get("name", "") - values = list(config.get("list", [])) - if raw_name == "area": - values = self._merge_area_filter(values) - if raw_name == "year" and current_year not in values: - index = values.index("全部") + 1 if "全部" in values else 0 - values.insert(index, current_year) - entries.append( - { - "key": "by" if raw_name == "sort" else raw_name, - "name": name_map.get(raw_name, raw_name), - "value": [{"n": value, "v": value} for value in values], - } - ) - filters[item.get("type_id", "")] = entries - return filters - - def homeContent(self, filter): - init_data = self._api_post(self.init_api) or {"type_list": [], "config": {}} - self.search_verify = bool(init_data.get("config", {}).get("system_search_verify_status")) - return { - "class": self._process_classes(init_data.get("type_list", [])), - "filters": self._convert_filters(init_data.get("type_list", [])), - "list": [vod for item in init_data.get("type_list", []) for vod in item.get("recommend_list", [])], - } - - def _page_result(self, items, pg, limit=90, total=None): - page = int(pg) - return { - "page": page, - "limit": limit, - "total": len(items) if total is None else total, - "list": items, - } - - def _merge_area_search(self, tid, pg, extend): - seen = set() - merged = [] - for area in self.area_merge_config.get("mergeList", []): - payload = { - "type_id": str(tid), - "page": str(pg), - "area": area, - "year": extend.get("year", "全部"), - "sort": extend.get("by", "最新"), - "lang": extend.get("lang", "全部"), - "class": extend.get("class", "全部"), - } - result = self._api_post("typeFilterVodList", payload) or {} - for item in result.get("recommend_list", []): - vod_id = item.get("vod_id") - if vod_id in seen: - continue - seen.add(vod_id) - merged.append(item) - return merged - - def categoryContent(self, tid, pg, filter, extend): - options = dict(extend or {}) - if options.get("area") == self.area_merge_config.get("displayName"): - return self._page_result(self._merge_area_search(tid, pg, options), pg) - payload = { - "type_id": str(tid), - "page": str(pg), - "area": options.get("area", "全部"), - "year": options.get("year", "全部"), - "sort": options.get("by", "最新"), - "lang": options.get("lang", "全部"), - "class": options.get("class", "全部"), - } - result = self._api_post("typeFilterVodList", payload) or {} - return self._page_result(result.get("recommend_list", []), pg) - - def searchContent(self, key, quick, pg="1"): - payload = { - "keywords": str(key or ""), - "type_id": "0", - "page": str(pg), - } - result = self._api_post(self.search_api, payload) or {} - keyword = str(key or "").strip().lower() - items = [] - for item in result.get("search_list", []): - vod_class = str(item.get("vod_class", "")) - text = " ".join( - [ - str(item.get("vod_name", "")), - str(item.get("vod_remarks", "")), - vod_class, - ] - ).lower() - if "伦理" in vod_class: - continue - if keyword and keyword not in text: - continue - items.append( - { - "vod_id": item.get("vod_id", ""), - "vod_name": item.get("vod_name", ""), - "vod_pic": item.get("vod_pic", ""), - "vod_remarks": " ".join( - value for value in [str(item.get("vod_year", "")), vod_class] if value - ).strip(), - } - ) - return self._page_result(items, pg) - - def _get_line_config(self, name): - return self.line_config.get(str(name or "")) - - def _line_display(self, name): - config = self._get_line_config(name) - return config.get("displayName", name) if config else name - - def _line_order(self, name): - config = self._get_line_config(name) - return config.get("order", 999) if config else 999 - - def _line_mode(self, name): - config = self._get_line_config(name) - return config.get("mode", "direct") if config else "direct" - - def _line_blocked(self, name): - config = self._get_line_config(name) - return bool(config) and config.get("enabled") is False - - def _player_headers(self): - return {"User-Agent": "Dalvik/2.1.0 (Linux; Android 14)"} - - def detailContent(self, ids): - items = [] - for vod_id in ids: - payload = {"vod_id": str(vod_id)} - data = self._api_post("vodDetail", payload) or self._api_post("vodDetail2", payload) - if not data: - continue - lines = [] - name_count = {} - fallback_index = 1 - for line in data.get("vod_play_list", []): - player_info = line.get("player_info", {}) - raw_name = str(player_info.get("show", "")) - if any(keyword in raw_name for keyword in ["防走丢", "群", "防失群", "官网"]): - raw_name = f"{fallback_index}线" - fallback_index += 1 - name_count[raw_name] = name_count.get(raw_name, 0) + 1 - line_name = raw_name if name_count[raw_name] == 1 else f"{raw_name}{name_count[raw_name]}" - if self._line_blocked(line_name): - continue - urls = [] - for vod in line.get("urls", []): - payload_text = ",".join( - [ - str(player_info.get("parse", "")), - str(vod.get("url", "")), - "token+" + str(vod.get("token", "")), - str(player_info.get("player_parse_type", "")), - str(player_info.get("parse_type", "")), - ] - ) - urls.append(f"{vod.get('name', '')}${line_name}@@{self._line_mode(line_name)}@@{payload_text}") - if urls: - lines.append( - { - "display": self._line_display(line_name), - "order": self._line_order(line_name), - "urls": "#".join(urls), - } - ) - lines.sort(key=lambda item: item["order"]) - vod = data.get("vod", {}) - items.append( - { - "vod_id": str(vod_id), - "vod_name": vod.get("vod_name", ""), - "vod_pic": vod.get("vod_pic", ""), - "vod_remarks": vod.get("vod_remarks", ""), - "vod_content": vod.get("vod_content", ""), - "vod_actor": str(vod.get("vod_actor", "")).replace("演员", ""), - "vod_director": str(vod.get("vod_director", "")).replace("导演", ""), - "vod_year": f"{vod.get('vod_year', '')}年" if vod.get("vod_year") else "", - "vod_area": vod.get("vod_area", ""), - "vod_play_from": "$$$".join(line["display"] for line in lines), - "vod_play_url": "$$$".join(line["urls"] for line in lines), - } - ) - return {"list": items} - - def playerContent(self, flag, id, vipFlags): - parts = str(id or "").split("@@", 2) - line_name = parts[0] if len(parts) > 0 else "" - mode = parts[1] if len(parts) > 1 else "direct" - payload = parts[2] if len(parts) > 2 else "" - if self._line_blocked(line_name): - return {"parse": 0, "jx": 0, "url": "", "header": {}} - if mode == "auto": - return {"parse": 0, "jx": 0, "url": "", "header": {}} - fields = payload.split(",", 4) - while len(fields) < 5: - fields.append("") - parse_api, play_url, token_with_prefix, player_parse_type, parse_type = fields - real_url = unquote(play_url) - token = token_with_prefix.replace("token+", "", 1) - if parse_type == "0": - return {"parse": 0, "jx": 0, "url": real_url, "header": self._player_headers()} - if parse_type == "2": - return {"parse": 1, "jx": 1, "url": parse_api + real_url, "header": self._player_headers()} - if player_parse_type == "2": - response = self.fetch(parse_api + real_url, headers=self._headers(), timeout=10, verify=False) - data = json.loads(response.text or "{}") - if data.get("url"): - return {"parse": 0, "jx": 0, "url": data.get("url", ""), "header": {}} - result = self._api_post( - "vodParse", - { - "parse_api": parse_api, - "url": self._aes_encrypt(real_url), - "player_parse_type": player_parse_type, - "token": token, - }, - ) or {} - try: - inner = json.loads(result.get("json", "{}")) - except Exception: - inner = {} - return {"parse": 0, "jx": 0, "url": inner.get("url", ""), "header": {}} diff --git a/py/黑猫APP.txt b/py/黑猫APP.txt new file mode 100644 index 0000000..662384a --- /dev/null +++ b/py/黑猫APP.txt @@ -0,0 +1,15 @@ +// ignore +//@name:黑猫APP +//@version:1 +//@remark: +//@format:secspider/1 +//@alg:aes-256-gcm +//@wrap:hkdf-aes-keywrap +//@sign:ed25519 +//@kid:k2026_04 +//@nonce:base64:S8lxZaR4FMqCfIy6 +//@ek:base64:YtFt7cr5zn4PtVpMzNRToXwtL021yTjFJlrsi5F13LLaWzieILhi4wOyIKo+9C9P +//@hash:sha256:b9193e5a355759bee2b7aca5543e5c6c015b668ba41c1dd928360d8e165fe95c +//@sig:base64:+yeyczhibKQIQWd7vPlPHT7jt5dio/N34qBirlGyRyAxTIuFyKsf7xwRrQma+lDMI8/GnUNO+2W+Q80RDTpEBw== +// ignore +payload.base64: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 \ No newline at end of file