import sys
import time
import csv
import idna
import re
import random
import logging
from time import sleep
from bs4 import BeautifulSoup
from urllib.parse import urljoin, quote
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException
from webdriver_manager.chrome import ChromeDriverManager
import urllib3
import signal

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

logging.basicConfig(
filename=’parser.log’,
level=logging.INFO,
format=’%(asctime)s — %(levelname)s — %(message)s’
)

DOMAIN = «китайавто.рус»
PUNYCODE_DOMAIN = idna.encode(DOMAIN).decode(‘ascii’)
BASE_URL = f»https://{PUNYCODE_DOMAIN}»
CAPTCHA_URL = urljoin(BASE_URL, «/captcha/show-captcha»)
CHERY_CATALOG_URL = urljoin(BASE_URL, «/catalog/zapcasti-chery»)

class ParserState:
def __init__(self):
self.current_model = None
self.current_category = None
self.current_part = None

class GracefulExiter:
def __init__(self):
self.state = False
signal.signal(signal.SIGINT, self.change_state)

def change_state(self, signum, frame):
print(«\nЗавершение работы…»)
self.state = True

def exit(self):
return self.state

def init_driver():
chrome_options = Options()
chrome_options.add_argument(«—headless»)
chrome_options.add_argument(«—disable-gpu»)
chrome_options.add_argument(«—no-sandbox»)
chrome_options.add_argument(«—disable-dev-shm-usage»)
chrome_options.add_argument(«—window-size=1920,1080»)

driver = webdriver.Chrome(
service=Service(ChromeDriverManager().install()),
options=chrome_options
)
return driver

def handle_captcha(driver, state):
try:
if CAPTCHA_URL in driver.current_url:
logging.info(«Прохожу капчу…»)
print(f»Прохожу капчу :)»)
submit_button = driver.find_element(By.CSS_SELECTOR, ‘button.btn-primary’)
submit_button.click()
#sleep(0.5)

try:
chery_link = driver.find_element(By.XPATH, ‘//a[@href=»/catalog/zapcasti-chery»]’)
chery_link.click()
except NoSuchElementException:
driver.get(CHERY_CATALOG_URL)

#sleep(0.5)

if state.current_model:
driver.get(state.current_model)
if state.current_category:
driver.get(state.current_category)
if state.current_part:
driver.get(state.current_part)
return True
except Exception as e:
logging.error(f»Ошибка обработки капчи: {str(e)}»)
driver.save_screenshot(«captcha_error.png»)
print(f»Ошибка капчи. Скрин в папке»)
return False

def extract_models(soup):
models = []
items = soup.find_all(‘div’, class_=lambda x: x and ‘catalog-item’ in x)

for item in items:
try:
name_block = item.find(‘div’, class_=’catalog-item-name’)
if not name_block:
continue

a_tag = name_block.find(‘a’, href=True)
if a_tag:
model_name = a_tag.get_text(strip=True)
model_url = urljoin(BASE_URL, a_tag[‘href’])
models.append((model_name, model_url))

except Exception as e:
logging.warning(f»Ошибка обработки элемента модели: {str(e)}»)

return models

def extract_categories(soup):
categories = []
carousel_items = soup.find_all(‘div’, class_=’new-catalog__catalog-detail-carousel-item’)

for item in carousel_items:
try:
name_div = item.find(‘div’, class_=’new-catalog___catalog-detail-carousel-item-name’)
if name_div:
category_name = name_div.get_text(strip=True)
a_tag = item.find(‘a’, href=True)
if a_tag and ‘/catalog/’ in a_tag[‘href’]:
cat_url = urljoin(BASE_URL, a_tag[‘href’])
categories.append((category_name, cat_url))
except Exception as e:
logging.warning(f»Ошибка обработки элемента категории: {str(e)}»)

unique_categories = []
seen = set()
for name, url in categories:
if url not in seen:
seen.add(url)
unique_categories.append((name, url))

return unique_categories

def extract_parts(soup):
«»»Извлечение данных о запчастях с приоритетом data-articul»»»
parts = []
items = soup.find_all(‘li’)

for item in items:
a_tag = item.find(‘a’, href=True, attrs={«data-articul»: True})
if not a_tag:
continue

part_number = a_tag.get(‘data-articul’, »).strip()

part_name = a_tag.get_text(» «, strip=True)

if ‘ ‘ in part_name:
part_name = part_name.split(‘ ‘, 1)[1].strip()

if ‘ ‘ in part_name:
part_name = part_name.rsplit(‘ ‘, 1)[0].strip()

part_name = re.sub(r’\s+’, ‘ ‘, part_name).strip()

part_url = urljoin(BASE_URL, a_tag[‘href’])

parts.append((part_name, part_number, part_url))

return parts

def extract_part_details(driver, part_url):
«»»Извлечение изображения со страницы деталей»»»
try:
driver.get(part_url)
sleep(0.3)

soup = BeautifulSoup(driver.page_source, ‘html.parser’)

image_link = soup.find(‘a’, class_=’default-image’, href=True)
if image_link:
return urljoin(BASE_URL, image_link[‘href’])

# Вар2: Изображение в таблице
img_tag = soup.find(‘img’, src=lambda x: x and ‘uploads/images’ in x)
if img_tag:
return urljoin(BASE_URL, img_tag[‘src’])

return «Нет изображения»

except Exception as e:
logging.error(f»Ошибка получения изображения: {str(e)}»)
return «Ошибка»

def parse_models(driver, state):
try:
driver.get(CHERY_CATALOG_URL)
if handle_captcha(driver, state):
return parse_models(driver, state)

#sleep(random.uniform(1, 3))
driver.execute_script(«window.scrollTo(0, document.body.scrollHeight);»)
#sleep(1)

soup = BeautifulSoup(driver.page_source, ‘html.parser’)
return extract_models(soup)

except Exception as e:
logging.error(f»Ошибка при парсинге моделей: {str(e)}»)
raise

def parse_categories(driver, model_url, state):
try:
state.current_model = model_url
driver.get(model_url)
if handle_captcha(driver, state):
return parse_categories(driver, model_url, state)

#sleep(random.uniform(2, 3))
driver.execute_script(«window.scrollTo(0, document.body.scrollHeight);»)
#sleep(1)

soup = BeautifulSoup(driver.page_source, ‘html.parser’)
return extract_categories(soup)

except Exception as e:
logging.error(f»Ошибка при парсинге категорий: {str(e)}»)
raise

def parse_parts(driver, category_url, state):
try:
state.current_category = category_url
driver.get(category_url)
if handle_captcha(driver, state):
return parse_parts(driver, category_url, state)

driver.execute_script(«window.scrollTo(0, document.body.scrollHeight);»)

soup = BeautifulSoup(driver.page_source, ‘html.parser’)
parts = extract_parts(soup)

if not parts:
print(«Пустая категория»)
raise ValueError(«Пустая категория»)

return parts

except Exception as e:
logging.error(f»Ошибка при парсинге запчастей: {str(e)}»)
raise

def parse_part_details(driver, part_url, state):
«»»Парсинг деталей запчасти и извлечение URL изображения»»»
try:
state.current_part = part_url
driver.get(part_url)

if handle_captcha(driver, state):
return parse_part_details(driver, part_url, state)

return extract_part_details(driver, part_url)

except Exception as e:
logging.error(f»Ошибка при парсинге деталей: {str(e)}»)
return «ошибка»

def main():
driver = init_driver()
state = ParserState()
grace_exit = GracefulExiter()

try:
print(«Запуск парсера»)
models = parse_models(driver, state)
print(f»\nНайдено моделей: {len(models)}»)

with open(‘chery_parts.csv’, ‘w’, newline=», encoding=’utf-8-sig’) as file:
writer = csv.writer(file, delimiter=’\t’, quoting=csv.QUOTE_MINIMAL)
writer.writerow([‘Модель’, ‘Категория’, ‘Запчасть’, ‘Код’, ‘Фото’])
processed_articles = set()

for model_name, model_url in models:
if grace_exit.exit():
break

print(f»\nНачало обработки модели: {model_name}»)

try:
categories = parse_categories(driver, model_url, state)
print(f»Найдено категорий: {len(categories)}»)

for category_name, category_url in categories:
if grace_exit.exit():
break

print(f»\n—————————————Обработка категории: {category_name} для {model_name}»)

try:
parts = parse_parts(driver, category_url, state)
print(f»Найдено запчастей: {len(parts)}»)

for part_name, part_number, part_url in parts:
if grace_exit.exit():
break

clean_number = part_number.strip()
if clean_number in processed_articles:
continue
processed_articles.add(clean_number)

image_url = parse_part_details(driver, part_url, art, state)

writer.writerow([
model_name.strip(),
category_name.strip(),
part_name.strip(),
clean_number,
image_url.strip() if image_url else «нет фото»
])

print(f»з/ч: {part_name} | {clean_number}»)

except Exception as e:
print(f»Ошибка в категории: {str(e)}»)
continue

except Exception as e:
print(f»Ошибка модели: {str(e)}»)
continue

print(«\nГотово! Результаты сохранены в chery_parts.csv»)

except Exception as e:
logging.critical(f»Критическая ошибка: {str(e)}»)
finally:
print(«Работа завершена»)
driver.quit()
if grace_exit.exit():
print(«Работа прервана пользователем»)

if __name__ == «__main__»:
main()