220 lines
8.3 KiB
Python
220 lines
8.3 KiB
Python
#!/usr/bin/env python3
|
|
"""Поиск вакансий на hh.ru через парсинг страницы поиска (без API)."""
|
|
import json
|
|
import os
|
|
import re
|
|
import time
|
|
import urllib.parse
|
|
|
|
import requests
|
|
|
|
HEADERS = {
|
|
"User-Agent": ("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
|
|
"(KHTML, like Gecko) Chrome/120.0 Safari/537.36"),
|
|
"Accept-Language": "ru-RU,ru;q=0.9",
|
|
}
|
|
|
|
SEARCH_URL = "https://hh.ru/search/vacancy"
|
|
|
|
|
|
def get_proxies():
|
|
"""Прокси из .env: PROXY_URL=http://LOGIN:PASS@HOST:PORT.
|
|
Возвращает dict для requests или None."""
|
|
url = os.environ.get("PROXY_URL", "")
|
|
if not url:
|
|
return None
|
|
return {"http": url, "https": url}
|
|
|
|
|
|
def _clean(text):
|
|
"""Убираем HTML-теги и лишние пробелы."""
|
|
text = re.sub(r"<[^>]+>", "", text)
|
|
text = text.replace("\xa0", " ")
|
|
return re.sub(r"\s+", " ", text).strip()
|
|
|
|
|
|
def _extract_salary(card_html):
|
|
"""Зарплата из <data value='...'> внутри карточки."""
|
|
values = re.findall(r'<data value="(\d+)">', card_html)
|
|
if not values:
|
|
return None
|
|
nums = [int(v) for v in values]
|
|
if len(nums) >= 2:
|
|
return {"from": nums[0], "to": nums[1]}
|
|
return {"from": nums[0], "to": None}
|
|
|
|
|
|
def parse_search_page(html):
|
|
"""Разбираем HTML страницы поиска в список вакансий."""
|
|
vacancies = []
|
|
# Разбиваем страницу на карточки
|
|
card_parts = re.split(r'data-qa="vacancy-serp__vacancy"', html)
|
|
for part in card_parts[1:]:
|
|
# Ссылка и название
|
|
m = re.search(r'data-qa="serp-item__title"[^>]*href="([^"]+)"[^>]*>(.*?)</a>', part, re.S)
|
|
if not m:
|
|
continue
|
|
href, title_html = m.group(1), m.group(2)
|
|
title = _clean(title_html)
|
|
if not title:
|
|
continue
|
|
|
|
# Компания
|
|
m = re.search(r'data-qa="vacancy-serp__vacancy-employer"[^>]*>(.*?)</a>', part, re.S)
|
|
company = _clean(m.group(1)) if m else None
|
|
|
|
# Адрес
|
|
m = re.search(r'data-qa="vacancy-serp__vacancy-address"[^>]*>(.*?)</span>', part, re.S)
|
|
address = _clean(m.group(1)) if m else None
|
|
|
|
# Опыт работы
|
|
m = re.search(r'data-qa="vacancy-serp__vacancy-work-experience-([^"]+)"', part)
|
|
experience = m.group(1) if m else None
|
|
|
|
# ID вакансии
|
|
m = re.search(r"/vacancy/(\d+)", href)
|
|
vacancy_id = m.group(1) if m else None
|
|
|
|
vacancies.append({
|
|
"id": vacancy_id,
|
|
"title": title,
|
|
"company": company,
|
|
"address": address,
|
|
"experience": experience,
|
|
"salary": _extract_salary(part),
|
|
"url": href.split("?")[0],
|
|
})
|
|
return vacancies
|
|
|
|
|
|
def parse_cookies(cookie_str):
|
|
"""Разбирает cookies в словарь. Поддерживает два формата:
|
|
1. JSON из расширений (Cookie-Editor): [{"name": ..., "value": ...}, ...]
|
|
2. Строка вида 'name1=value1; name2=value2'
|
|
"""
|
|
cookies = {}
|
|
if not cookie_str:
|
|
return cookies
|
|
s = cookie_str.strip()
|
|
# Формат JSON
|
|
if s.startswith("["):
|
|
try:
|
|
items = json.loads(s)
|
|
for item in items:
|
|
if isinstance(item, dict) and item.get("name"):
|
|
val = str(item.get("value", ""))
|
|
if _is_latin1(val):
|
|
cookies[item["name"]] = val
|
|
return cookies
|
|
except Exception:
|
|
pass
|
|
# Формат name=value; ...
|
|
for part in s.split(";"):
|
|
part = part.strip()
|
|
if "=" in part:
|
|
k, v = part.split("=", 1)
|
|
if _is_latin1(v):
|
|
cookies[k.strip()] = v.strip()
|
|
return cookies
|
|
|
|
|
|
def _is_latin1(s):
|
|
"""HTTP-заголовки требуют latin-1: пропускаем cookies с другими символами."""
|
|
try:
|
|
s.encode("latin-1")
|
|
return True
|
|
except UnicodeEncodeError:
|
|
return False
|
|
|
|
|
|
def search_vacancies(query, area=None, pages=1, per_page=20, delay=2.0, cookies=None, proxies=None):
|
|
"""Ищем вакансии по запросу. Возвращает список словарей."""
|
|
all_vacancies = []
|
|
seen = set()
|
|
for page_num in range(pages):
|
|
params = {"text": query, "page": page_num, "per_page": per_page}
|
|
if area:
|
|
params["area"] = area
|
|
url = f"{SEARCH_URL}?{urllib.parse.urlencode(params)}"
|
|
resp = requests.get(url, headers=HEADERS, timeout=30, cookies=cookies, proxies=proxies)
|
|
if resp.status_code != 200:
|
|
print(f" [поиск] HTTP {resp.status_code} для страницы {page_num}")
|
|
break
|
|
found = parse_search_page(resp.text)
|
|
if not found:
|
|
print(f" [поиск] страница {page_num}: вакансий не найдено (возможно, капча)")
|
|
break
|
|
for v in found:
|
|
if v["id"] and v["id"] not in seen:
|
|
seen.add(v["id"])
|
|
all_vacancies.append(v)
|
|
if len(found) < per_page:
|
|
break
|
|
time.sleep(delay) # вежливая пауза между страницами
|
|
return all_vacancies
|
|
|
|
|
|
def fetch_vacancy_details(vacancy_id, cookies=None, proxies=None):
|
|
"""Получаем описание вакансии со страницы вакансии."""
|
|
url = f"https://hh.ru/vacancy/{vacancy_id}"
|
|
resp = requests.get(url, headers=HEADERS, timeout=30, cookies=cookies, proxies=proxies)
|
|
if resp.status_code != 200:
|
|
return None
|
|
html = resp.text
|
|
details = {"id": vacancy_id, "url": url}
|
|
|
|
m = re.search(r'data-qa="vacancy-title"[^>]*>(.*?)</h1>', html, re.S)
|
|
details["title"] = _clean(m.group(1)) if m else None
|
|
|
|
m = re.search(r'data-qa="vacancy-company-name"[^>]*>(.*?)</a>', html, re.S)
|
|
details["company"] = _clean(m.group(1)) if m else None
|
|
|
|
m = re.search(r'data-qa="vacancy-salary"[^>]*>(.*?)</div>', html, re.S)
|
|
details["salary"] = _clean(m.group(1)) if m else None
|
|
|
|
m = re.search(r'data-qa="vacancy-description"[^>]*>(.*?)</div>\s*</div>', html, re.S)
|
|
details["description"] = _clean(m.group(1)) if m else None
|
|
if details["description"]:
|
|
details["description"] = details["description"][:3000]
|
|
|
|
return details
|
|
|
|
|
|
def fetch_my_resumes(cookies=None, proxies=None):
|
|
"""Получает список резюме пользователя со страницы hh.ru/applicant/resumes.
|
|
Возвращает список {"id": hash, "title": ..., "updated": ...}."""
|
|
url = "https://hh.ru/applicant/resumes"
|
|
resp = requests.get(url, headers=HEADERS, timeout=30, cookies=cookies, proxies=proxies)
|
|
if resp.status_code != 200:
|
|
return None, f"HTTP {resp.status_code} — проверьте ключ сессии"
|
|
html = resp.text
|
|
if "resume" not in html.lower() and "Войти" in html:
|
|
return None, "Сессия недействительна — страница требует входа"
|
|
|
|
resumes = []
|
|
seen = set()
|
|
# Блоки резюме: ищем ссылки /resume/{hash} (hash = hex-строка 30-50 символов)
|
|
for m in re.finditer(r'/resume/([a-f0-9]{30,50})', html):
|
|
hid = m.group(1)
|
|
if hid in seen:
|
|
continue
|
|
seen.add(hid)
|
|
# Ищем заголовок резюме рядом (до 1500 символов после ссылки)
|
|
chunk = html[m.start():m.start() + 1500]
|
|
title_m = re.search(r'data-qa="title"[^>]*>(.*?)</h3>', chunk, re.S)
|
|
title = _clean(title_m.group(1)) if title_m else None
|
|
if not title:
|
|
title_m = re.search(r'data-qa="resume-title"[^>]*>(.*?)<', chunk, re.S)
|
|
title = _clean(title_m.group(1)) if title_m else "Без названия"
|
|
resumes.append({"id": hid, "title": title})
|
|
return resumes, None
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
query = sys.argv[1] if len(sys.argv) > 1 else "python developer"
|
|
print(f"Ищу: {query}")
|
|
result = search_vacancies(query, pages=1)
|
|
print(f"Найдено: {len(result)}")
|
|
for v in result[:5]:
|
|
print(f" {v['id']} | {v['title']} | {v['company']} | {v['salary']}") |