基本完成

This commit is contained in:
2026-08-25 22:53:57 +08:00
parent 05fa686749
commit 252d5b53ac
39 changed files with 3853 additions and 447 deletions
+352 -201
View File
@@ -1,85 +1,187 @@
"""
投递自动化模块
在后台线程运行,支持用户随时开始/结束。
向云端服务端上报投递记录与统计。
投递自动化模块(低痕迹 CDP 版 · 期望条件栏驱动)
真实页面行为(已实测):
- 列表页 /web/geek/jobs 顶部有"期望搜索条件"栏(如 Java(北京)),
点击某条期望即由站点自身发请求加载对应 关键词+城市 的职位列表;
找不到目标城市的期望时,告知"期望城市没有目标城市"。
- 分页为下拉加载:滚动触发站点自身 XHR(list.json),被动监听可得明文薪资
(DOM 中薪资为自定义字体加密,无法直接读取)。
- 投递:右侧详情面板点"立即沟通"→ 站点自动发送默认招呼语并弹出
"已向BOSS发送消息"对话框 → 点"留在此页"即完成一次投递。
- 沟通按钮需浏览器级可信点击(Input.dispatchMouseEvent),合成 el.click() 无效。
"""
import json
import random
import re
import time
import threading
from dataclasses import dataclass
from loguru import logger
from .cdp_lite import LiteCDP, CDPSession
from .manager import BrowserManager
from ..ai import AIClient
from ..server_api import ServerAPI
# 职位列表页(注意是 jobs 复数)
JOBS_PAGE = "https://www.zhipin.com/web/geek/jobs"
# 常见城市编码 → 名称(用于在期望条件栏匹配目标城市)
CITY_NAMES = {
"101010100": "北京", "101020100": "上海", "101280100": "广州",
"101280600": "深圳", "101190100": "杭州", "101030100": "天津",
"101200100": "武汉", "101110100": "西安", "101270100": "成都",
"101040100": "重庆", "101190400": "苏州", "101200200": "南京",
"101210100": "合肥", "101180100": "郑州", "101230100": "福州",
"101240100": "南昌", "101250100": "济南", "101260100": "贵阳",
"101290100": "昆明", "101300100": "兰州", "101050100": "哈尔滨",
"101060100": "长春", "101070100": "沈阳", "101080100": "呼和浩特",
"101090100": "石家庄", "101100100": "太原", "101120100": "青岛",
"101190500": "宁波", "101280300": "佛山", "101280200": "珠海",
"101120200": "大连", "101210200": "厦门", "101180200": "开封",
"101200300": "无锡", "101190200": "温州", "101270200": "绵阳",
}
@dataclass
class JobCard:
job_id: str
title: str
company: str
salary: str
location: str
hr_active: str
can_chat: bool
can_deliver: bool
tags: str = ""
salary: str = ""
jd_text: str = ""
boss_online: bool = False
# 读取列表卡片(新版 DOM 结构)
_CARDS_JS = """(() => [...document.querySelectorAll('.job-card-wrap')].map(el => {
const a = el.querySelector('a.job-name');
const m = /\\/job_detail\\/([^.]+)\\.html/.exec(a ? (a.getAttribute('href') || '') : '');
const t = s => { const n = el.querySelector(s); return n ? n.innerText.trim() : ''; };
return {job_id: m ? m[1] : '', title: t('.job-name'), company: t('.boss-name'),
location: t('.company-location'), tags: t('.tag-list'),
online: !!el.querySelector('.boss-online-icon')};
}))()"""
# JD 正文(详情页,明文)
_JD_JS = """(() => {
const el = document.querySelector('.job-sec-text') || document.querySelector('.job-detail-section');
return el ? el.innerText.trim() : '';
})()"""
def _select_expect_js(keyword: str, city_name: str) -> str:
"""在期望条件栏查找目标期望(优先 关键词(城市) 全匹配,其次城市匹配),返回坐标供可信点击"""
return ("((kw, city) => (() => {"
"const items = [...document.querySelectorAll('.expect-item')];"
"const txt = el => ((el.querySelector('.text-content') || el).innerText || '').trim();"
"let hit = city && items.find(el => txt(el) === kw + '(' + city + ')');"
"if (!hit && city) hit = items.find(el => txt(el).endsWith('(' + city + ')'));"
"if (!hit && kw) hit = items.find(el => txt(el).toLowerCase().includes(kw.toLowerCase()));"
"if (!hit) return JSON.stringify({ok: false, list: items.map(txt)});"
"const r = hit.getBoundingClientRect();"
"return JSON.stringify({ok: true, text: txt(hit),"
" x: r.x + r.width / 2, y: r.y + r.height / 2});"
"})())(" + json.dumps(keyword, ensure_ascii=False) + ","
+ json.dumps(city_name, ensure_ascii=False) + ")")
def _click_card_js(job_id: str) -> str:
"""定位指定职位卡片并滚动到可视区,返回坐标供可信点击(右侧面板随之加载该职位)"""
return ("((id) => (() => {"
"const el = [...document.querySelectorAll('.job-card-wrap')]"
".find(c => ((c.querySelector('a.job-name') || {getAttribute: () => ''})"
".getAttribute('href') || '').includes(id));"
"if (!el) return null;"
"el.scrollIntoView({block: 'center'});"
"const r = el.getBoundingClientRect();"
"return JSON.stringify({x: r.x + r.width / 2, y: r.y + r.height / 2});"
"})())(" + json.dumps(job_id) + ")")
def _btn_xy_js(selector: str) -> str:
return (f"(() => {{ const b = document.querySelector('{selector}'); if (!b) return null;"
"const r = b.getBoundingClientRect();"
"return JSON.stringify({x: r.x + r.width / 2, y: r.y + r.height / 2}); })()")
_STAY_JS = """(() => {
const b = [...document.querySelectorAll('a,button,div,span')]
.find(e => (e.innerText || '').trim() === '留在此页' && e.offsetHeight > 0);
if (!b) return null;
const r = b.getBoundingClientRect();
return JSON.stringify({x: r.x + r.width / 2, y: r.y + r.height / 2});
})()"""
def _parse_salary(text: str) -> tuple[int, int] | None:
"""'20-30K·15薪' → (20, 30);'3K以下' → (0, 3);'50K以上' → (50, 999)"""
if not text:
return None
m = re.search(r"(\d+)\s*-\s*(\d+)\s*K", text)
if m:
return int(m.group(1)), int(m.group(2))
m = re.search(r"(\d+)\s*K以下", text)
if m:
return 0, int(m.group(1))
m = re.search(r"(\d+)\s*K以上", text)
if m:
return int(m.group(1)), 999
return None
class Applicant:
"""投递执行器(可启停)"""
BASE_URL = "https://www.zhipin.com"
def __init__(
self,
manager: BrowserManager,
server_api: ServerAPI,
ai_client: AIClient | None,
):
def __init__(self, manager: BrowserManager, server_api: ServerAPI,
ai_client: AIClient | None):
self.manager = manager
self.server = server_api
self.ai = ai_client
self.cdp = LiteCDP()
# 运行控制
self._stop_event = threading.Event()
self._thread: threading.Thread | None = None
self.is_running = False
# 运行时状态(供 Web 面板查询)
self.session_id: int | None = None
self.primary_resume_content: str = ""
self.stats = {"applied": 0, "skipped": 0, "current": ""}
# 列表页会话(整个任务期间保持一个标签页)
self._tab: dict | None = None
self._sess: CDPSession | None = None
self._salary_by_id: dict[str, str] = {}
# ------------------------------------------------------------------
# 启停控制
# ------------------------------------------------------------------
def start(self, keywords: list[str], city_code: str,
salary_min: int | None, salary_max: int | None,
greeting: str, min_score: int, delay_range: tuple[int, int]) -> None:
"""在新线程中启动投递任务"""
greeting: str, min_score: int, delay_range: tuple[int, int],
boss_online_only: bool = False, daily_limit: int = 0) -> None:
if self.is_running:
logger.warning("已有投递任务在运行")
return
# 创建服务端会话
session = self.server.start_session(
keywords=",".join(keywords),
city_code=city_code,
salary_min=salary_min,
salary_max=salary_max,
keywords=",".join(keywords), city_code=city_code,
salary_min=salary_min, salary_max=salary_max,
)
self.session_id = session["id"]
# 获取主简历内容
primary = self.server.get_primary_resume()
self.primary_resume_content = primary["content"] if primary else ""
self._stop_event.clear()
self.is_running = True
self.stats = {"applied": 0, "skipped": 0, "current": "初始化..."}
self.boss_online_only = boss_online_only
self.daily_limit = daily_limit
self._daily_base = 0
self._thread = threading.Thread(
target=self._run,
@@ -91,12 +193,20 @@ class Applicant:
logger.success(f"投递任务已启动,会话 ID:{self.session_id}")
def stop(self) -> None:
"""请求停止投递任务"""
logger.info("收到停止投递请求...")
self._stop_event.set()
def _should_stop(self) -> bool:
return self._stop_event.is_set()
def _sleep(self, min_s: float, max_s: float) -> None:
total = random.uniform(min_s, max_s)
elapsed = 0.0
while elapsed < total and not self._should_stop():
time.sleep(0.5)
elapsed += 0.5
def _finish(self) -> None:
"""任务结束后的收尾工作"""
self.is_running = False
if self.session_id:
try:
@@ -104,13 +214,8 @@ class Applicant:
except Exception as e:
logger.warning(f"结束会话失败:{e}")
self.stats["current"] = "已停止"
logger.info(
f"投递任务结束。本次投递 {self.stats['applied']} 个,"
f"跳过 {self.stats['skipped']} 个"
)
def _should_stop(self) -> bool:
return self._stop_event.is_set()
logger.info(f"投递任务结束。本次投递 {self.stats['applied']} 个,"
f"跳过 {self.stats['skipped']} 个")
# ------------------------------------------------------------------
# 主循环
@@ -118,44 +223,141 @@ class Applicant:
def _run(self, keywords, city_code, salary_min, salary_max,
greeting, min_score, delay_range):
try:
self.manager.ensure_browser_started()
# 整个任务只开一个列表标签页,模拟真人持续浏览
self._tab = self.cdp.open_tab(JOBS_PAGE)
time.sleep(8) # 等 SPA 挂载
self._sess = CDPSession(self._tab["webSocketDebuggerUrl"])
self._sess.call("Network.enable")
# 每日上限:任务开始时拉取当天已投数量
if self.daily_limit:
try:
self._daily_base = self.server.today_applied_count()
except Exception as e:
logger.warning(f"获取当天投递数量失败,上限判断跳过:{e}")
self._daily_base = 0
logger.info(f"当天已投递 {self._daily_base} 个,每日上限 {self.daily_limit}")
if self._daily_base >= self.daily_limit:
logger.info("已达当日投递上限,任务直接结束")
return
city_name = CITY_NAMES.get(str(city_code), "")
for keyword in keywords:
if self._should_stop():
break
self.stats["current"] = f"搜索关键词:{keyword}"
self._process_keyword(
keyword, city_code, salary_min, salary_max,
greeting, min_score, delay_range,
)
if not self._should_stop():
self._sleep(5, 9)
self.stats["current"] = f"匹配期望条件:{keyword}"
if not self._select_expect(keyword, city_name):
continue
self._process_list(keyword, salary_min, salary_max,
min_score, delay_range)
self._sleep(3, 6)
except Exception as e:
logger.error(f"投递任务异常:{e}")
finally:
if self._sess:
self._sess.close()
if self._tab:
self.cdp.close_tab(self._tab["id"])
self._finish()
def _process_keyword(self, keyword, city_code, salary_min, salary_max,
greeting, min_score, delay_range, max_per_keyword: int = 15):
page = 1
applied_in_kw = 0
while applied_in_kw < max_per_keyword and not self._should_stop():
cards = self._fetch_job_list(keyword, city_code, salary_min, salary_max, page)
if not cards:
break
for card in cards:
if self._should_stop():
return
if applied_in_kw >= max_per_keyword:
break
applied_in_kw += self._handle_card(card, greeting, min_score, delay_range)
page += 1
# 翻页前随机停顿,模拟真人翻页节奏,避免连续翻页被识别为机器行为
if applied_in_kw < max_per_keyword and not self._should_stop():
self._sleep(2, 5)
def _select_expect(self, keyword: str, city_name: str) -> bool:
"""可信点击目标期望;找不到目标城市时告知并跳过"""
r = self._sess.eval_js(_select_expect_js(keyword, city_name))
try:
info = json.loads(r or "{}")
except Exception:
info = {}
if not info.get("ok"):
logger.warning(f"期望城市没有目标城市:{keyword}"
f"({city_name or '未配置城市名'}),"
f"现有期望:{info.get('list') or '无'}")
return False
self._sess.click_at(info["x"], info["y"])
logger.info(f"已选中期望条件:{info.get('text')}")
time.sleep(2)
# 点击后站点自发请求第一页列表,被动监听捕获明文薪资
self._pump_list_responses(4)
time.sleep(2) # 列表渲染可能滞后,留出缓冲
return True
def _handle_card(self, card: JobCard, greeting: str, min_score: int,
delay_range: tuple[int, int]) -> int:
"""处理单个职位卡片,返回是否投递成功(1/0)"""
# 1. 去重(服务端查询)
# ------------------------------------------------------------------
# 列表读取与下拉分页
# ------------------------------------------------------------------
def _pump_list_responses(self, duration: float) -> None:
"""被动监听站点自身的 list.json 分页响应,收集明文薪资"""
reqs: dict[str, str] = {}
for msg in self._sess.pump(duration):
m = msg.get("method")
if m == "Network.responseReceived":
url = msg["params"]["response"]["url"]
if "list.json" in url:
reqs[msg["params"]["requestId"]] = url
elif m == "Network.loadingFinished":
rid = msg["params"]["requestId"]
if rid in reqs:
try:
body = self._sess.call(
"Network.getResponseBody", {"requestId": rid}).get("body", "")
jobs = json.loads(body).get("zpData", {}).get("jobList") or []
for j in jobs:
if j.get("encryptJobId"):
self._salary_by_id[j["encryptJobId"]] = j.get("salaryDesc") or ""
except Exception:
pass
def _read_cards(self) -> list[JobCard]:
raw = self._sess.eval_js(_CARDS_JS)
if isinstance(raw, str):
try:
raw = json.loads(raw or "[]")
except Exception:
raw = []
items = raw or []
cards = []
for it in items:
if not it.get("job_id"):
continue
it["salary"] = self._salary_by_id.get(it["job_id"], "")
cards.append(JobCard(
job_id=it.get("job_id", ""), title=it.get("title", ""),
company=it.get("company", ""), location=it.get("location", ""),
tags=it.get("tags", ""), salary=it.get("salary", ""),
boss_online=bool(it.get("online")),
))
return cards
def _process_list(self, keyword, salary_min, salary_max,
min_score, delay_range, max_per_keyword: int = 15):
processed: set[str] = set()
applied = 0
no_new = 0
while applied < max_per_keyword and not self._should_stop():
cards = self._read_cards()
new_cards = [c for c in cards if c.job_id not in processed]
if not new_cards:
no_new += 1
if no_new >= 2:
logger.info(f"关键词 {keyword} 已无更多职位")
break
else:
no_new = 0
for card in new_cards:
if self._should_stop() or applied >= max_per_keyword:
break
processed.add(card.job_id)
applied += self._handle_card(card, salary_min, salary_max,
min_score, delay_range)
# 下拉加载下一页:滚动到底,站点自发请求,被动监听
self._sess.eval_js("window.scrollTo(0, document.body.scrollHeight)")
self._pump_list_responses(3)
self._sleep(1, 3)
# ------------------------------------------------------------------
# 单职位处理:去重 → 薪资 → JD+AI → 投递
# ------------------------------------------------------------------
def _handle_card(self, card: JobCard, salary_min, salary_max,
min_score, delay_range) -> int:
try:
if self.server.check_applied(card.job_id):
return 0
@@ -164,50 +366,119 @@ class Applicant:
self.stats["current"] = f"评估:{card.company} - {card.title}"
# 2. 抓取 JD 详情(供 AI 评分与归档记录,统一前置)
if not card.jd_text:
card.jd_text = self._fetch_jd_detail(card)
# 薪资范围过滤(薪资来自站点分页响应明文)
if salary_min or salary_max:
rng = _parse_salary(card.salary)
if rng:
lo = salary_min or 0
hi = salary_max or 999
if rng[1] < lo or rng[0] > hi:
self._report_skip(card, f"薪资不符({card.salary})")
return 0
# 只投在线 Boss:卡片 logo 旁无绿点直接跳过
if self.boss_online_only and not card.boss_online:
self._report_skip(card, "Boss不在线")
return 0
# 每日上限:达到后结束整个任务
if self.daily_limit and self._daily_base + self.stats["applied"] >= self.daily_limit:
logger.info(f"已达当日投递上限({self.daily_limit}),任务结束")
self._stop_event.set()
return 0
# JD 详情(临时标签页,读完即关)供 AI 评分
card.jd_text = self._fetch_jd(card)
# 3. AI 匹配度评分
ai_score, ai_reason = -1, ""
if self.ai and self.ai.available() and self.primary_resume_content:
result = self.ai.score_job(card.jd_text, self.primary_resume_content)
ai_score, ai_reason = result.score, result.reason
logger.info(f"AI 评分 {ai_score}(及格线 {min_score}):"
f"{card.company} - {card.title} | {ai_reason}")
if not result.is_worth_applying(min_score):
self._report_skip(card, f"AI 评分低({ai_score})", ai_score, ai_reason)
return 0
else:
logger.debug(f"AI 评分不可用,跳过评分:{card.company} - {card.title}")
# 4. 执行投递
success, apply_type = self._apply(card, greeting)
if success:
# 打招呼语仅 chat 方式实际发送过,才归档
greeting_used = greeting if (apply_type == "chat" and greeting) else None
self._report_apply(card, apply_type, ai_score, ai_reason, greeting_used)
if self._apply(card):
self._report_apply(card, ai_score, ai_reason)
self._sleep(*delay_range)
return 1
return 0
def _fetch_jd(self, card: JobCard) -> str:
tab = None
try:
tab = self.cdp.open_tab(
f"https://www.zhipin.com/job_detail/{card.job_id}.html")
time.sleep(5)
s = CDPSession(tab["webSocketDebuggerUrl"])
try:
jd = s.eval_js(_JD_JS) or ""
finally:
s.close()
return jd.strip() or f"{card.title} {card.company}"
except Exception:
return f"{card.title} {card.company}"
finally:
if tab:
self.cdp.close_tab(tab["id"])
# 临时标签夺走了焦点,恢复列表标签前台,否则可信点击失效
if self._tab:
self.cdp.activate_tab(self._tab["id"])
time.sleep(1)
def _apply(self, card: JobCard) -> bool:
"""选中卡片 → 可信点击立即沟通 → 点留在此页,完成一次投递"""
# 1. 选中卡片(右侧面板加载该职位)
pos = self._sess.eval_js(_click_card_js(card.job_id))
if not pos:
logger.warning(f"未能在列表中选中卡片:{card.title}")
return False
p = json.loads(pos)
self._sess.click_at(p["x"], p["y"])
time.sleep(1.5)
# 2. 可信点击"立即沟通"
xy = self._sess.eval_js(_btn_xy_js(".op-btn-chat"))
if not xy:
logger.warning(f"右侧面板无立即沟通按钮:{card.title}")
return False
p = json.loads(xy)
self._sess.click_at(p["x"], p["y"])
# 3. 等待"已向BOSS发送消息"弹窗,点"留在此页"
for _ in range(10):
time.sleep(1)
stay = self._sess.eval_js(_STAY_JS)
if stay:
q = json.loads(stay)
self._sess.click_at(q["x"], q["y"])
return True
logger.warning(f"点击立即沟通后未等到发送消息弹窗:{card.title}")
return False
# ------------------------------------------------------------------
# 服务端上报
# ------------------------------------------------------------------
def _report_apply(self, card: JobCard, apply_type: str, ai_score: int, ai_reason: str,
greeting: str | None = None):
def _report_apply(self, card: JobCard, ai_score: int, ai_reason: str):
try:
self.server.report_application(self.session_id, {
"job_id": card.job_id,
"job_title": card.title,
"company": card.company,
"salary": card.salary,
"salary": card.salary or None,
"location": card.location,
"apply_type": apply_type,
"apply_type": "chat",
"ai_score": ai_score,
"ai_reason": ai_reason[:255] if ai_reason else None,
"jd_text": card.jd_text or None,
"greeting": greeting,
})
self.server.update_session_stats(self.session_id, applied_delta=1, skipped_delta=0)
self.stats["applied"] += 1
logger.success(f"[{self.stats['applied']}] 投递成功({apply_type}):{card.company} - {card.title}")
logger.success(f"[{self.stats['applied']}] 投递成功:{card.company} - {card.title}")
except Exception as e:
logger.warning(f"上报投递记录失败:{e}")
@@ -217,7 +488,8 @@ class Applicant:
"job_id": card.job_id,
"job_title": card.title,
"company": card.company,
"salary": card.salary,
"salary": card.salary or None,
"location": card.location,
"apply_type": "skipped",
"ai_score": ai_score,
"ai_reason": ai_reason[:255] if ai_reason else None,
@@ -229,124 +501,3 @@ class Applicant:
logger.info(f"跳过({reason}):{card.company} - {card.title}")
except Exception as e:
logger.debug(f"上报跳过记录失败:{e}")
# ------------------------------------------------------------------
# 页面操作
# ------------------------------------------------------------------
def _fetch_job_list(self, keyword, city_code, salary_min, salary_max, page) -> list[JobCard]:
page_obj = self.manager.ensure_connected()
url = f"{self.BASE_URL}/web/geek/job?query={keyword}&city={city_code}&page={page}"
if salary_min or salary_max:
url += f"&salary={(salary_min or 0) * 1000},{(salary_max or 0) * 1000}"
self.stats["current"] = f"加载职位列表 第{page}页"
try:
page_obj.goto(url, wait_until="domcontentloaded", timeout=30000)
page_obj.wait_for_timeout(2500)
page_obj.wait_for_selector(".job-card-wrapper", timeout=10000)
except Exception:
logger.warning(f"第 {page} 页无职位列表")
return []
cards = []
for el in page_obj.query_selector_all(".job-card-wrapper"):
try:
card = self._parse_card(el)
if card:
cards.append(card)
except Exception:
continue
logger.info(f"第 {page} 页解析到 {len(cards)} 个职位")
return cards
def _parse_card(self, el) -> JobCard | None:
def text(sel: str) -> str:
node = el.query_selector(sel)
return node.inner_text().strip() if node else ""
link = el.query_selector("a.job-card-left")
href = link.get_attribute("href") if link else ""
m = re.search(r"/job_detail/(\w+)\.html", href or "")
if not m:
return None
return JobCard(
job_id=m.group(1),
title=text(".job-name"),
company=text(".company-name"),
salary=text(".salary"),
location=text(".job-area"),
hr_active=text(".info-public"),
can_chat=bool(el.query_selector(".start-chat-btn:not([disabled])")),
can_deliver=bool(el.query_selector(".btn-deliver")),
)
def _fetch_jd_detail(self, card: JobCard) -> str:
page_obj = self.manager.page
try:
page_obj.goto(f"{self.BASE_URL}/job_detail/{card.job_id}.html",
wait_until="domcontentloaded", timeout=20000)
page_obj.wait_for_timeout(1500)
el = page_obj.query_selector(".job-detail-section")
jd = el.inner_text().strip() if el else f"{card.title} {card.company}"
page_obj.go_back()
page_obj.wait_for_timeout(1500)
return jd
except Exception:
return f"{card.title} {card.company}"
def _apply(self, card: JobCard, greeting: str) -> tuple[bool, str]:
if card.can_chat and self._do_chat(card, greeting):
return True, "chat"
if card.can_deliver and self._do_deliver(card):
return True, "deliver"
return False, ""
def _do_chat(self, card: JobCard, greeting: str) -> bool:
page_obj = self.manager.page
try:
btn = page_obj.query_selector(f"[data-job-id='{card.job_id}'] .start-chat-btn")
if not btn:
return False
btn.click()
page_obj.wait_for_timeout(2000)
if greeting:
inp = page_obj.query_selector(".chat-input textarea")
if inp:
inp.fill(greeting)
page_obj.wait_for_timeout(500)
send = page_obj.query_selector(".chat-input .btn-send")
if send:
send.click()
page_obj.wait_for_timeout(1500)
close = page_obj.query_selector(".dialog-container .close-btn")
if close:
close.click()
return True
except Exception as e:
logger.debug(f"立即沟通失败:{e}")
return False
def _do_deliver(self, card: JobCard) -> bool:
page_obj = self.manager.page
try:
btn = page_obj.query_selector(f"[data-job-id='{card.job_id}'] .btn-deliver")
if not btn:
return False
btn.click()
page_obj.wait_for_timeout(2000)
confirm = page_obj.query_selector(".dialog-confirm .btn-sure")
if confirm:
confirm.click()
page_obj.wait_for_timeout(1500)
return True
except Exception as e:
logger.debug(f"投递简历失败:{e}")
return False
def _sleep(self, min_s: float, max_s: float) -> None:
# 分段睡眠以便及时响应停止信号
total = random.uniform(min_s, max_s)
elapsed = 0.0
while elapsed < total and not self._should_stop():
time.sleep(0.5)
elapsed += 0.5
+239
View File
@@ -0,0 +1,239 @@
"""
Boss直聘 低痕迹 CDP 客户端
背景:Boss直聘 风控会探测"标签页被 CDP attach",一旦被 Playwright 接管,
页面会被重置为 about:blank。因此所有浏览器操作走无 attach 痕迹的原生通道:
- 导航:DevTools HTTP 协议(/json/new),由浏览器自身加载页面
- 读 Cookie:CDP WebSocket 的 Network.getCookies(不激活任何调试域)
- 读 DOM:CDP WebSocket 的 Runtime.evaluate(一次性表达式求值)
"""
import json
import time
from html.parser import HTMLParser
import requests
import websocket
from loguru import logger
from ..config import client_settings
class TextExtractor(HTMLParser):
"""从 HTML 片段中提取可见文本(跳过 script/style)"""
SKIP = {"script", "style", "noscript", "svg", "iframe"}
def __init__(self):
super().__init__()
self.parts: list[str] = []
self._skip_depth = 0
def handle_starttag(self, tag, attrs):
if tag in self.SKIP:
self._skip_depth += 1
elif tag in ("div", "p", "li", "br", "tr", "section", "h1", "h2", "h3", "h4"):
self.parts.append("\n")
def handle_endtag(self, tag):
if tag in self.SKIP and self._skip_depth > 0:
self._skip_depth -= 1
def handle_data(self, data):
if self._skip_depth == 0 and data.strip():
self.parts.append(data.strip())
def text(self) -> str:
lines = [ln.strip() for ln in "".join(self.parts).splitlines()]
return "\n".join(ln for ln in lines if ln)
def extract_text(html: str) -> str:
parser = TextExtractor()
parser.feed(html)
return parser.text()
class CDPSession:
"""单个标签页上的持久 CDP 会话:命令调用 / 事件泵 / 可信鼠标点击。
只启用必要域(Network 被动监听站点自身 XHR,Input 产生浏览器级可信点击),
不 attach 页面、不注入脚本,保持低痕迹。"""
def __init__(self, ws_url: str):
self.ws = websocket.create_connection(ws_url, timeout=30)
self._id = 0
def call(self, method: str, params: dict | None = None, timeout: float = 10) -> dict:
self._id += 1
mid = self._id
self.ws.send(json.dumps({"id": mid, "method": method, "params": params or {}}))
self.ws.settimeout(timeout)
while True:
msg = json.loads(self.ws.recv())
if msg.get("id") == mid:
return msg.get("result") or {}
def eval_js(self, expression: str, timeout: float = 10):
"""一次性表达式求值,返回结果值"""
return (self.call("Runtime.evaluate",
{"expression": expression, "returnByValue": True}, timeout)
.get("result", {}).get("value"))
def pump(self, duration: float):
"""在 duration 秒内持续产出 CDP 事件(用于被动监听网络响应)"""
self.ws.settimeout(0.5)
end = time.time() + duration
while time.time() < end:
try:
yield json.loads(self.ws.recv())
except Exception:
continue
def click_at(self, x: float, y: float) -> None:
"""浏览器级可信鼠标点击(isTrusted=true,与真人鼠标无异)"""
self.call("Input.dispatchMouseEvent", {
"type": "mousePressed", "x": int(x), "y": int(y),
"button": "left", "clickCount": 1})
time.sleep(0.08)
self.call("Input.dispatchMouseEvent", {
"type": "mouseReleased", "x": int(x), "y": int(y),
"button": "left", "clickCount": 1})
def close(self) -> None:
try:
self.ws.close()
except Exception:
pass
class LiteCDP:
"""无 Playwright 依赖的浏览器操作封装"""
def __init__(self):
self.debug_port = client_settings.BROWSER_DEBUG_PORT
# ------------------------------------------------------------------
# DevTools HTTP 协议
# ------------------------------------------------------------------
def _endpoint(self) -> str:
return f"http://127.0.0.1:{self.debug_port}"
def is_running(self) -> bool:
try:
resp = requests.get(f"{self._endpoint()}/json/version", timeout=3)
return resp.status_code == 200
except Exception:
return False
def list_tabs(self) -> list[dict]:
try:
return requests.get(f"{self._endpoint()}/json", timeout=5).json()
except Exception:
return []
def open_tab(self, url: str) -> dict:
"""原生方式新开标签页并导航(浏览器自身加载,无自动化痕迹)"""
r = requests.put(f"{self._endpoint()}/json/new?{url}", timeout=10)
if r.status_code == 405: # 部分 Chrome 版本只接受 GET
r = requests.get(f"{self._endpoint()}/json/new?{url}", timeout=10)
r.raise_for_status()
return r.json()
def close_tab(self, tab_id: str) -> None:
try:
requests.get(f"{self._endpoint()}/json/close/{tab_id}", timeout=5)
except Exception:
pass
def activate_tab(self, tab_id: str) -> None:
"""重新激活指定标签页。开/关临时标签会夺走焦点,
后台标签上的可信鼠标点击不生效,必须恢复前台。"""
try:
requests.get(f"{self._endpoint()}/json/activate/{tab_id}", timeout=5)
except Exception:
pass
def activate_tab(self, tab_id: str) -> None:
"""重新激活指定标签页(开/关临时标签会夺走焦点,
后台标签上的可信鼠标点击会失效,需恢复前台)"""
try:
requests.get(f"{self._endpoint()}/json/activate/{tab_id}", timeout=5)
except Exception:
pass
def tab_url(self, tab_id: str) -> str | None:
for t in self.list_tabs():
if t.get("id") == tab_id:
return t.get("url")
return None
# ------------------------------------------------------------------
# CDP WebSocket(只发必要的命令,不激活 Page/Runtime/Debugger 域监听)
# ------------------------------------------------------------------
def evaluate(self, ws_url: str, expression: str, timeout: float = 20):
"""一次性表达式求值,返回结果值;失败返回 None"""
ws = websocket.create_connection(ws_url, timeout=timeout)
try:
ws.send(json.dumps({
"id": 1,
"method": "Runtime.evaluate",
"params": {"expression": expression, "returnByValue": True},
}))
while True:
msg = json.loads(ws.recv())
if msg.get("id") == 1:
return msg.get("result", {}).get("result", {}).get("value")
finally:
try:
ws.close()
except Exception:
pass
def get_cookie_names(self) -> set[str]:
"""读取 zhipin 域 Cookie 名称集合(取任一标签页的 ws 通道即可)"""
tabs = [t for t in self.list_tabs() if t.get("webSocketDebuggerUrl")]
if not tabs:
return set()
ws = websocket.create_connection(tabs[0]["webSocketDebuggerUrl"], timeout=10)
try:
ws.send(json.dumps({
"id": 1,
"method": "Network.getCookies",
"params": {"urls": ["https://www.zhipin.com/"]},
}))
while True:
msg = json.loads(ws.recv())
if msg.get("id") == 1:
cookies = msg.get("result", {}).get("cookies", [])
return {c["name"] for c in cookies}
finally:
try:
ws.close()
except Exception:
pass
# ------------------------------------------------------------------
# 组合操作:开页 → 等渲染 → 取 DOM → 关页
# ------------------------------------------------------------------
def fetch_rendered_html(self, url: str, wait_s: float = 8,
max_wait_s: float = 20) -> str | None:
"""打开目标页等待 SPA 渲染,取回完整 HTML 后关闭标签页"""
tab = self.open_tab(url)
tab_id, ws_url = tab["id"], tab["webSocketDebuggerUrl"]
try:
deadline = time.time() + max_wait_s
waited = 0.0
html = ""
while time.time() < deadline:
time.sleep(2)
waited += 2
try:
html = self.evaluate(
ws_url, "document.documentElement.outerHTML") or ""
except Exception as e:
logger.debug(f"取 DOM 失败({waited}s):{e}")
continue
# 渲染完成的经验判断:内容足够长且非空壳
if len(html) > 50000 and waited >= wait_s:
return html
return html or None
finally:
self.close_tab(tab_id)
+215 -106
View File
@@ -1,33 +1,93 @@
"""
浏览器管理器
统一管理 AdsPower 浏览器启动与 Playwright CDP 连接。
统一收敛浏览器启动与 Playwright CDP 连接。
登录、抓取简历、投递共用同一个浏览器会话(复用登录态)。
支持两种模式(client/.env 的 BROWSER_MODE 切换):
- chrome :本机真实 Chrome/Edge + 独立 user-data-dir(默认,免费、反检测最好)
- adspower :AdsPower 指纹浏览器(需 Profile ID,部分 API 需付费)
"""
import os
import subprocess
import time
from pathlib import Path
import requests
from loguru import logger
from playwright.sync_api import sync_playwright, Playwright, Browser, BrowserContext, Page
from ..config import client_settings
from .cdp_lite import LiteCDP
BOSS_HOME = "https://www.zhipin.com/web/geek/job"
BOSS_RESUME_PAGE = "https://www.zhipin.com/web/geek/resume"
# Windows 下 Chrome / Edge 常见安装路径(按优先级自动探测)
_CANDIDATE_EXES = [
r"C:\Program Files\Google\Chrome\Application\chrome.exe",
r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
os.path.expandvars(r"%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe"),
r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
r"C:\Program Files\Microsoft\Edge\Application\msedge.exe",
]
def find_browser_exe() -> str | None:
"""探测本机浏览器可执行文件:配置优先,其次 Chrome,最后 Edge"""
if client_settings.BROWSER_PATH:
p = Path(client_settings.BROWSER_PATH)
return str(p) if p.exists() else None
for p in _CANDIDATE_EXES:
if Path(p).exists():
return p
return None
class BrowserManager:
"""管理 AdsPower 浏览器 + Playwright 连接"""
"""管理浏览器启动 + Playwright 连接(按 BROWSER_MODE 分派)"""
def __init__(self):
self.mode = (client_settings.BROWSER_MODE or "chrome").strip().lower()
# adspower 模式配置
self.api_url = client_settings.ADSPOWER_API_URL.rstrip("/")
self.user_id = client_settings.ADSPOWER_USER_ID
self._playwright: Playwright | None = None
self._browser: Browser | None = None
self._context: BrowserContext | None = None
self.page: Page | None = None
# chrome 模式配置
self.debug_port = client_settings.BROWSER_DEBUG_PORT
self._proc: subprocess.Popen | None = None
self.cdp_url: str | None = None
# 低痕迹 CDP 通道:Boss直聘 风控会探测 CDP attach,
# Playwright 接管页面会把页面重置为 about:blank,
# 因此登录检测/开用户标签页均走原生 DevTools 协议
self.lite = LiteCDP()
# 取账号名的后台复核只做一次,避免轮询期间反复开标签页
self._account_cached = False
self._account_name: str | None = None
# ------------------------------------------------------------------
# AdsPower 本地 API
# 可用性与运行状态
# ------------------------------------------------------------------
def check_available(self) -> None:
"""启动前置校验:当前模式所需环境是否就绪,不满足直接抛错"""
if self.mode == "adspower":
if not self.user_id:
raise RuntimeError("未配置 AdsPower Profile ID(ADSPOWER_USER_ID)")
if not self.is_adspower_running():
raise RuntimeError("AdsPower 软件未运行,请先打开 AdsPower")
else:
if not find_browser_exe():
raise RuntimeError(
"未检测到 Chrome/Edge,请安装 Chrome 或在 .env 中配置 BROWSER_PATH"
)
def is_browser_running(self) -> bool:
"""浏览器是否已在运行(adspower=软件在线;chrome=调试端口可达)"""
if self.mode == "adspower":
return self.is_adspower_running()
try:
resp = requests.get(f"{self._cdp_endpoint()}/json/version", timeout=3)
return resp.status_code == 200
except Exception:
return False
def is_adspower_running(self) -> bool:
try:
resp = requests.get(f"{self.api_url}/status", timeout=5)
@@ -35,7 +95,19 @@ class BrowserManager:
except Exception:
return False
def start_adspower_browser(self) -> str:
# ------------------------------------------------------------------
# 浏览器启动(按模式分派)
# ------------------------------------------------------------------
def _cdp_endpoint(self) -> str:
return f"http://127.0.0.1:{self.debug_port}"
def start_browser(self) -> str:
"""启动浏览器并返回 CDP 地址"""
if self.mode == "adspower":
return self._start_adspower_browser()
return self._start_local_browser()
def _start_adspower_browser(self) -> str:
"""启动 AdsPower 浏览器,返回 CDP 地址"""
url = f"{self.api_url}/api/v1/browser/start"
resp = requests.get(url, params={"user_id": self.user_id, "open_tabs": 1}, timeout=30)
@@ -47,7 +119,140 @@ class BrowserManager:
logger.success(f"AdsPower 浏览器已启动,CDP: {self.cdp_url}")
return self.cdp_url
def stop_adspower_browser(self) -> None:
def _start_local_browser(self) -> str:
"""以 CDP 调试端口启动本机真实浏览器,独立 profile 目录持久化登录态"""
if self.is_browser_running():
logger.info("检测到浏览器调试端口已存在,直接复用")
return self._cdp_endpoint()
exe = find_browser_exe()
if not exe:
raise RuntimeError("未检测到 Chrome/Edge,请安装 Chrome 或在 .env 中配置 BROWSER_PATH")
profile_dir = client_settings.BROWSER_PROFILE_DIR or str(
Path(__file__).resolve().parents[1] / "data" / "chrome_profile"
)
Path(profile_dir).mkdir(parents=True, exist_ok=True)
self._proc = subprocess.Popen(
[
exe,
f"--remote-debugging-port={self.debug_port}",
f"--user-data-dir={profile_dir}",
"--no-first-run",
"--no-default-browser-check",
# 允许 WebSocket 连接 CDP(新版 Chrome 默认拒绝非白名单 origin)
"--remote-allow-origins=*",
# 首次启动直接带上目标网址:由 Chrome 自己打开首个标签页,
# 该标签页不归程序管,程序永远不会导航/关闭它
BOSS_HOME,
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
# 等待调试端口就绪(最多 20 秒)
for _ in range(40):
if self.is_browser_running():
logger.success(f"浏览器已启动:{exe}(profile:{profile_dir})")
return self._cdp_endpoint()
time.sleep(0.5)
raise RuntimeError("浏览器启动超时,请检查调试端口是否被占用")
# ------------------------------------------------------------------
# 浏览器确保就绪(不 attach 任何页面,无风控痕迹)
# ------------------------------------------------------------------
def ensure_browser_started(self) -> str:
"""确保浏览器已启动,返回 CDP 地址(已运行则直接复用)"""
self.check_available()
return self.start_browser()
# ------------------------------------------------------------------
# 登录状态检测(全部走低痕迹通道,不 attach 页面)
# ------------------------------------------------------------------
def open_user_tab(self, url: str) -> None:
"""为用户打开一个目标页(浏览器已在运行、首启页被关掉的场景)。
走原生 DevTools 协议由浏览器自己加载,打开后程序不再触碰。"""
try:
self.lite.open_tab(url)
except Exception as e:
logger.warning(f"打开页面失败:{e}")
def has_login_cookie(self) -> bool:
"""轻量登录判断:只读 Cookie,不创建/导航任何标签页(零刷新)。
注意:只认 wt2(真正的登录凭证);__zp_stoken__ 是游客 token,
未登录时也存在,不能作为登录依据。"""
if not self.lite.is_running():
return False
try:
return "wt2" in self.lite.get_cookie_names()
except Exception as e:
logger.debug(f"读 Cookie 失败:{e}")
return False
def check_boss_login(self) -> bool:
"""
检测 Boss直聘 是否已登录。
只读 Cookie(wt2),不创建任何标签页,轮询期间零刷新;
全程不触碰用户标签页。
"""
logged_in = self.has_login_cookie()
if logged_in and not self._account_cached:
logger.success("检测到已登录 Boss直聘")
return logged_in
def get_boss_account_name(self) -> str | None:
"""获取登录用户名:从首页 _PAGE 变量提取(开一个后台标签页,
一次性表达式求值后立即关闭,结果缓存,只开这一次)"""
if self._account_cached:
return self._account_name
self._account_cached = True
tab = None
try:
tab = self.lite.open_tab("https://www.zhipin.com/")
time.sleep(5)
# 页面内嵌的 _PAGE 变量含登录用户名,比 DOM 选择器稳定
name = self.lite.evaluate(
tab["webSocketDebuggerUrl"],
"(typeof _PAGE !== 'undefined' && _PAGE.name) ? _PAGE.name : "
"((document.querySelector('.user-nav .name') || "
"document.querySelector('.header-login .name')) ? "
"(document.querySelector('.user-nav .name') || "
"document.querySelector('.header-login .name')).innerText.trim() : '')",
)
self._account_name = (name or "").strip() or None
except Exception as e:
logger.debug(f"获取账号名失败:{e}")
self._account_name = None
finally:
if tab:
self.lite.close_tab(tab["id"])
return self._account_name
# ------------------------------------------------------------------
# 关闭
# ------------------------------------------------------------------
def close(self) -> None:
"""兼容保留:低痕迹模式下无连接可释放,什么都不做"""
def close_all(self) -> None:
"""关闭连接并停止浏览器(仅停止本管理器启动的进程/AdsPower 窗口)"""
self.close()
if self.mode == "adspower":
self._stop_adspower_browser()
return
if self._proc:
try:
self._proc.terminate()
self._proc.wait(timeout=5)
except Exception:
try:
self._proc.kill()
except Exception:
pass
self._proc = None
logger.info("本地浏览器已关闭")
def _stop_adspower_browser(self) -> None:
try:
requests.get(
f"{self.api_url}/api/v1/browser/stop",
@@ -56,99 +261,3 @@ class BrowserManager:
logger.info("AdsPower 浏览器已关闭")
except Exception as e:
logger.warning(f"关闭 AdsPower 浏览器失败:{e}")
# ------------------------------------------------------------------
# Playwright 连接
# ------------------------------------------------------------------
def connect(self) -> Page:
"""启动浏览器并通过 CDP 连接,返回可操作的 page"""
if self.page is not None:
return self.page
if not self.user_id:
raise RuntimeError("未配置 AdsPower Profile ID(ADSPOWER_USER_ID)")
if not self.is_adspower_running():
raise RuntimeError("AdsPower 软件未运行,请先打开 AdsPower")
self.start_adspower_browser()
self._playwright = sync_playwright().start()
self._browser = self._playwright.chromium.connect_over_cdp(self.cdp_url)
contexts = self._browser.contexts
self._context = contexts[0] if contexts else self._browser.new_context()
pages = self._context.pages
self.page = pages[0] if pages else self._context.new_page()
logger.info("Playwright 已连接到 AdsPower 浏览器")
return self.page
def ensure_connected(self) -> Page:
"""确保已连接,返回 page"""
if self.page is None:
return self.connect()
return self.page
# ------------------------------------------------------------------
# 登录状态检测
# ------------------------------------------------------------------
def check_boss_login(self) -> bool:
"""
检测 Boss直聘 是否已登录。
通过访问首页并检查是否存在登录后才有的元素判断。
"""
page = self.ensure_connected()
try:
page.goto(BOSS_HOME, wait_until="domcontentloaded", timeout=30000)
page.wait_for_timeout(2000)
# 已登录:页面上会显示用户头像/用户名;未登录:会显示"登录/注册"
logged_in_indicators = [
".user-nav .user-info",
".nav-figure .user",
"[class*='avatar']",
".header-login .name",
]
for sel in logged_in_indicators:
if page.query_selector(sel):
logger.success("检测到已登录 Boss直聘")
return True
# 检查是否出现登录弹窗/登录按钮
if page.query_selector(".btn-sign-up, .login-register, [class*='login-btn']"):
return False
# 兜底:检查 cookie 中是否有登录凭证
cookies = page.context.cookies()
cookie_names = {c["name"] for c in cookies}
return "__zp_stoken__" in cookie_names or "wt2" in cookie_names
except Exception as e:
logger.warning(f"登录状态检测异常:{e}")
return False
def get_boss_account_name(self) -> str | None:
"""尝试获取登录用户名"""
page = self.ensure_connected()
try:
for sel in [".user-nav .name", ".header-login .name", ".user-info .name"]:
el = page.query_selector(sel)
if el:
return el.inner_text().strip()
except Exception:
pass
return None
# ------------------------------------------------------------------
# 关闭
# ------------------------------------------------------------------
def close(self) -> None:
"""关闭 Playwright 连接(不关闭 AdsPower 浏览器,保留登录态)"""
try:
if self._playwright:
self._playwright.stop()
except Exception:
pass
self._playwright = None
self._browser = None
self._context = None
self.page = None
def close_all(self) -> None:
"""关闭连接并停止 AdsPower 浏览器"""
self.close()
self.stop_adspower_browser()
+76 -100
View File
@@ -1,126 +1,102 @@
"""
AI 简历抓取模块
从已登录的 Boss直聘 账号中抓取所有简历,
并用 AI 整理成结构化文本后返回。
AI 简历抓取模块(低痕迹 CDP 版)
Boss直聘 的简历页是一份"在线简历"的分板块编辑页(不是一份份的简历列表),
板块以 id 区分:userinfo/summary/purpose/history/project/education/
clubExp/professional-skill。
通过原生 CDP 通道(不 attach 页面)读取各板块 innerText,拼装成结构化简历。
"""
import json
from loguru import logger
from .manager import BrowserManager, BOSS_RESUME_PAGE
from .cdp_lite import LiteCDP
from .manager import BOSS_RESUME_PAGE
# 在页面上一次性抽取各板块文本(返回 JSON 字符串)
_SECTION_JS = """(() => {
const ids = ['userinfo', 'summary', 'purpose', 'history', 'project',
'education', 'clubExp', 'professional-skill'];
const out = {};
for (const id of ids) {
const el = document.getElementById(id);
if (el) out[id] = el.innerText;
}
return JSON.stringify(out);
})()"""
# 板块标题(用于拼装简历文本)
SECTION_TITLES = {
"userinfo": "基本信息",
"summary": "个人优势",
"purpose": "期望职位",
"history": "工作经历",
"project": "项目经历",
"education": "教育经历",
"clubExp": "社团/组织经历",
"professional-skill": "专业技能",
}
class ResumeScraper:
"""抓取 Boss直聘 账号内的所有简历"""
"""抓取 Boss直聘 账号内的在线简历"""
def __init__(self, manager: BrowserManager, ai_client=None):
def __init__(self, manager, ai_client=None):
self.manager = manager
self.ai = ai_client
self.cdp = LiteCDP()
def scrape_all(self) -> list[dict]:
"""
抓取所有简历。
抓取在线简历。
返回格式:[{boss_resume_id, title, position, content}, ...]
"""
page = self.manager.ensure_connected()
logger.info("正在打开 Boss直聘 简历页...")
page.goto(BOSS_RESUME_PAGE, wait_until="domcontentloaded", timeout=30000)
page.wait_for_timeout(3000)
# 浏览器可能已被手动关闭,先确保拉起(复用登录态 profile)
self.manager.ensure_browser_started()
tab = self.cdp.open_tab(BOSS_RESUME_PAGE)
tab_id, ws_url = tab["id"], tab["webSocketDebuggerUrl"]
try:
import time
time.sleep(8) # 等 SPA 渲染完成
raw = self.cdp.evaluate(ws_url, _SECTION_JS)
finally:
self.cdp.close_tab(tab_id)
resumes: list[dict] = []
if not raw:
logger.warning("未能从简历页读取到内容")
return []
# 尝试多种可能的简历卡片选择器(Boss直聘 页面结构可能变化)
card_selectors = [
".resume-item",
".resume-card",
"[class*='resume-list'] li",
".geek-resume-item",
]
card_els = []
for sel in card_selectors:
card_els = page.query_selector_all(sel)
if card_els:
logger.info(f"使用选择器 {sel} 找到 {len(card_els)} 份简历")
break
try:
sections = json.loads(raw)
except Exception as e:
logger.warning(f"简历板块数据解析失败:{e}")
return []
if not card_els:
logger.warning("未通过卡片选择器找到简历,尝试整页抓取")
return self._scrape_whole_page(page)
if not sections:
logger.warning("简历页未找到任何板块,请确认已登录")
return []
for i, card in enumerate(card_els):
try:
resume = self._parse_resume_card(card, i)
if resume:
resumes.append(resume)
except Exception as e:
logger.debug(f"解析第 {i} 份简历失败:{e}")
# 拼装结构化简历文本
parts = []
for key, title in SECTION_TITLES.items():
text = (sections.get(key) or "").strip()
if text:
parts.append(f"【{title}】\n{text}")
content = "\n\n".join(parts)
logger.success(f"共抓取到 {len(resumes)} 份简历")
return resumes
# 从基本信息板块首行提取姓名作为标题
userinfo = (sections.get("userinfo") or "").strip()
name = userinfo.splitlines()[0].strip() if userinfo else ""
title = f"{name}的在线简历" if name else "我的在线简历"
def _parse_resume_card(self, card, index: int) -> dict | None:
"""解析单个简历卡片"""
def text(sel: str) -> str:
el = card.query_selector(sel)
return el.inner_text().strip() if el else ""
title = (
text(".resume-title") or text(".title") or
text(".name") or f"简历 {index + 1}"
)
position = text(".position") or text(".job-name") or text(".expect-position")
# 尝试点开详情获取完整内容
content = self._extract_detail_content(card) or text(".resume-content") or text("p")
# 用 AI 整理内容
if content and self.ai:
# 用 AI 整理内容(可选)
if content and self.ai and self.ai.available():
content = self.ai.clean_resume(content)
return {
"boss_resume_id": None, # Boss直聘 前端通常不暴露,后续可从 URL 提取
logger.success(f"简历抓取完成:{title},{len(content)} 字符")
return [{
"boss_resume_id": None, # Boss直聘 前端不暴露简历 ID
"title": title,
"position": position or None,
"position": None,
"content": content or None,
}
def _extract_detail_content(self, card) -> str | None:
"""尝试点击简历卡片进入详情页抓取完整内容"""
page = self.manager.page
try:
clickable = card.query_selector("a") or card
clickable.click()
page.wait_for_timeout(2000)
detail_selectors = [
".resume-detail",
".geek-resume-detail",
"[class*='resume-content']",
".resume-preview",
]
for sel in detail_selectors:
el = page.query_selector(sel)
if el:
content = el.inner_text().strip()
page.go_back()
page.wait_for_timeout(1500)
return content
page.go_back()
page.wait_for_timeout(1500)
except Exception as e:
logger.debug(f"提取简历详情失败:{e}")
return None
def _scrape_whole_page(self, page) -> list[dict]:
"""兜底方案:抓取整个简历页主体文本作为一份简历"""
body_selectors = [".main-wrap", ".geek-wrap", "main", "#main"]
for sel in body_selectors:
el = page.query_selector(sel)
if el:
content = el.inner_text().strip()
if content:
content = self.ai.clean_resume(content) if self.ai else content
return [{
"boss_resume_id": None,
"title": "我的在线简历",
"position": None,
"content": content,
}]
return []
}]