parser.py

import asyncio
from playwright.async_api import async_playwright
import json
import re
import time

async def parse_yandex_maps_detailed(city_name):
    """Детальный парсинг организаций из Яндекс.Карт с кликами по каждой организации"""
    
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        page = await browser.new_page()
        
        try:
            # Переходим на Яндекс.Карты
            print(f"🌍 Открываем Яндекс.Карты для города: {city_name}")
            await page.goto("https://yandex.ru/maps")
            await page.wait_for_timeout(3000)
            
            # Ищем поле поиска и вводим запрос
            print(f"🔍 Вводим поисковый запрос: 'производство {city_name}'")
            search_input = await page.wait_for_selector('input[placeholder*="Поиск"]', timeout=10000)
            await search_input.click()
            await search_input.fill(f"производство {city_name}")
            await search_input.press("Enter")
            
            # Ждем загрузки результатов
            print("Ждем загрузки результатов...")
            await page.wait_for_timeout(5000)
            
            # Обрабатываем несколько страниц результатов
            max_pages = 100  # Увеличиваем до 100 страниц
            all_organizations = []
            page_num = 1
            total_processed_cards = 0  # Общий счетчик обработанных карточек
            saved_count = 0  # Счетчик сохранений
            
            while page_num <= max_pages:
                print(f"\n=== Обрабатываем страницу {page_num} ===")
                
                # Прокручиваем боковую панель с результатами для загрузки всех результатов на текущей странице
                print("Прокручиваем боковую панель для загрузки всех результатов...")
                
                # Находим боковую панель
                search_panel = await page.query_selector('[class*="search-list-view"]') or \
                              await page.query_selector('[class*="search-results"]') or \
                              await page.query_selector('[class*="results"]')
                
                if search_panel:
                    # Используем wheel скроллинг с проверкой новых элементов
                    scroll_round = 0
                    max_rounds = 200 # Максимум 200 аундов по 5 прокруток
                    
                    while scroll_round < max_rounds:
                        scroll_round += 1
                        print(f"Раунд скроллинга {scroll_round}/{max_rounds}")
                        
                        # Запоминаем количество элементов до прокрутки
                        before_elements = await page.evaluate("""
                            () => {
                                const cards = document.querySelectorAll('button[role="button"], div[role="button"], a[href*="/maps/org/"]');
                                return cards.length;
                            }
                        """)
                        
                        # Прокручиваем 5 раз
                        for scroll in range(1):
                            await search_panel.hover()
                            await page.mouse.wheel(0, 1000)
                            await page.wait_for_timeout(300)
                            print(f"  Прокрутка {scroll + 1}/5")
                        
                        # Ждем загрузки и проверяем новые элементы
                        await page.wait_for_timeout(2000)
                        
                        after_elements = await page.evaluate("""
                            () => {
                                const cards = document.querySelectorAll('button[role="button"], div[role="button"], a[href*="/maps/org/"]');
                                return cards.length;
                            }
                        """)
                        
                        new_elements = after_elements - before_elements
                        print(f"  Элементов: {before_elements} → {after_elements} (+{new_elements})")
                        
                        # Если новых элементов нет, останавливаемся
                        if new_elements <= 0:
                            print("  Новых элементов не загрузилось, останавливаем скроллинг")
                            break
                        else:
                            print(f"  Загрузилось {new_elements} новых элементов, продолжаем...")
                else:
                    print("Боковая панель не найдена")
                
                # Ждем загрузки всех результатов
                await page.wait_for_timeout(3000)
                
                # Собираем данные об организациях на текущей странице
                print("Собираем данные об организациях...")
                organizations = []
                
                # Находим все карточки организаций на текущей странице
                org_cards = await page.query_selector_all('button[role="button"]')
                print(f"Найдено {len(org_cards)} кнопок button[role='button']")
                
                # Также ищем другие возможные селекторы карточек
                org_cards_div = await page.query_selector_all('div[role="button"]')
                print(f"Найдено {len(org_cards_div)} div[role='button']")
                
                org_cards_links = await page.query_selector_all('a[href*="/maps/org/"]')
                print(f"Найдено {len(org_cards_links)} ссылок на организации")
                
                # Объединяем все найденные элементы
                all_cards = org_cards + org_cards_div + org_cards_links
                print(f"Всего найдено элементов: {len(all_cards)}")
                
                # Убираем дубликаты
                unique_cards = []
                seen_texts = set()
                for card in all_cards:
                    try:
                        card_text = await card.text_content()
                        if card_text and card_text.strip():
                            if card_text not in seen_texts:
                                unique_cards.append(card)
                                seen_texts.add(card_text)
                    except:
                        continue
                
                print(f"Уникальных карточек: {len(unique_cards)}")
                org_cards = unique_cards
                
                print(f"Найдено {len(org_cards)} кнопок на странице")
                
                # Попробуем найти карточки по другому селектору
                if len(org_cards) == 0:
                    print("Пробуем альтернативный селектор...")
                    org_cards = await page.query_selector_all('div[role="button"]')
                    print(f"Найдено {len(org_cards)} div кнопок")
                else:
                    # Проверяем первые 5 карточек на наличие текста
                    empty_cards = 0
                    for card in org_cards[:5]:
                        if not await card.text_content():
                            empty_cards += 1
                    
                    if empty_cards >= 3:  # Если большинство карточек пустые
                        print("Пробуем альтернативный селектор...")
                        org_cards = await page.query_selector_all('div[role="button"]')
                        print(f"Найдено {len(org_cards)} div кнопок")
                
                processed_cards = 0
                page_organizations = []  # Организации только с текущей страницы
                
                for i, card in enumerate(org_cards[:1000]):  # Увеличиваем до 1000 на страницу
                    try:
                        # Проверяем, что элемент все еще прикреплен к DOM
                        try:
                            card_text = await card.text_content()
                        except:
                            print(f"Элемент {i+1} откреплен, пропускаем...")
                            continue
                        
                        processed_cards += 1
                        total_processed_cards += 1
                        print(f"Обрабатываем карточку {i+1}/{len(org_cards)}: {card_text[:50]}...")
                        
                        # Проверяем, что это карточка организации (простая проверка)
                        if card_text and len(card_text) > 10:
                            
                            # Получаем ссылку на организацию
                            org_link = await card.query_selector('a[href*="/maps/org/"]')
                            if org_link:
                                try:
                                    org_url = await org_link.get_attribute('href')
                                    if org_url and '/maps/org/' in org_url and not org_url.endswith('/prices/'):
                                        # Открываем организацию в новой вкладке
                                        new_page = await browser.new_page()
                                        try:
                                            await new_page.goto(f"https://yandex.ru{org_url}")
                                            await new_page.wait_for_timeout(5000)  # Увеличиваем до 5 секунд
                                            
                                            # Получаем детальную информацию
                                            org_data = await extract_organization_details(new_page, card_text)
                                            if org_data.get('name') and org_data.get('address'):
                                                # Проверяем, не дублируется ли организация
                                                is_duplicate = any(
                                                    existing_org['name'] == org_data['name'] and 
                                                    existing_org['address'] == org_data['address'] 
                                                    for existing_org in all_organizations
                                                )
                                                
                                                if not is_duplicate:
                                                    organizations.append(org_data)
                                                    page_organizations.append(org_data)
                                                    all_organizations.append(org_data)
                                                    print(f"✓ {org_data['name']} | {org_data['address']}")
                                                    
                                                    # Сохраняем после каждой организации
                                                    saved_count += 1
                                                    with open(f"{city_name.lower()}.json", "w", encoding="utf-8") as f:
                                                        json.dump(all_organizations, f, ensure_ascii=False, indent=2)
                                                    print(f"💾 Сохранено {saved_count} организаций в {city_name.lower()}.json")
                                                    
                                                    # Увеличиваем задержку для стабильности
                                                    await asyncio.sleep(3)
                                                else:
                                                    print(f"⚠ Дубликат: {org_data['name']} | {org_data['address']}")
                                                    # Увеличиваем задержку для дубликатов
                                                    await asyncio.sleep(2)
                                            else:
                                                print(f"✗ Не удалось извлечь данные для организации")
                                                # Увеличиваем задержку для неуспешных попыток
                                                await asyncio.sleep(5)
                                            
                                        except Exception as e:
                                            print(f"Ошибка при обработке страницы организации: {e}")
                                        finally:
                                            await new_page.close()
                                except Exception as e:
                                    print(f"Ошибка при получении ссылки: {e}")
                                    continue
                            else:
                                # Если ссылка не найдена, пробуем кликнуть на карточку
                                try:
                                    await card.click()
                                    await page.wait_for_timeout(5000)  # Увеличиваем до 5 секунд
                                    
                                    org_data = await extract_organization_details(page, card_text)
                                    
                                    # Проверяем, не дублируется ли организация
                                    is_duplicate = any(
                                        existing_org['name'] == org_data['name'] and 
                                        existing_org['address'] == org_data['address'] 
                                        for existing_org in all_organizations
                                    )
                                    
                                    if not is_duplicate:
                                        organizations.append(org_data)
                                        page_organizations.append(org_data)
                                        all_organizations.append(org_data)
                                        print(f"✓ {org_data['name']} | {org_data['address']}")
                                        
                                        # Сохраняем после каждой организации
                                        saved_count += 1
                                        with open(f"{city_name.lower()}.json", "w", encoding="utf-8") as f:
                                            json.dump(all_organizations, f, ensure_ascii=False, indent=2)
                                        print(f"💾 Сохранено {saved_count} организаций в {city_name.lower()}.json")
                                        
                                        # Увеличиваем задержку для стабильности
                                        await asyncio.sleep(3)
                                    else:
                                        print(f"⚠ Дубликат: {org_data['name']} | {org_data['address']}")
                                        # Короткая задержка для дубликатов
                                        await asyncio.sleep(0.5)
                                    
                                    # Возвращаемся к списку результатов
                                    await page.go_back()
                                    await page.wait_for_timeout(2000)
                                except Exception as e:
                                    print(f"Ошибка при клике на карточку: {e}")
                                    continue
                            
                            # Ограничиваем количество организаций на странице
                            if len(page_organizations) >= 500:
                                break
                                
                    except Exception as e:
                        print(f"Ошибка при обработке организации {i+1}: {e}")
                        # Если элемент откреплен, продолжаем со следующей карточкой
                        if "not attached to the DOM" in str(e):
                            print("Элемент откреплен, пропускаем...")
                        continue
                
                # Организации уже добавлены в all_organizations при обработке
                print(f"Страница {page_num}: найдено {len(organizations)} организаций")
                print(f"Всего организаций: {len(all_organizations)}")
                print(f"Всего обработано карточек: {total_processed_cards}")
                
                # Проверяем, есть ли организации на странице
                if len(page_organizations) == 0:
                    print("⚠ ВНИМАНИЕ: На текущей странице не найдено ни одной организации!")
                    print("Возможно, достигнут конец результатов или есть проблема с парсингом")
                
                # Промежуточные результаты уже сохранены после каждой организации
                
                # Проверяем, есть ли следующая страница
                if page_num < max_pages:
                    try:
                        # Используем JavaScript для перехода на следующую страницу
                        next_page_result = await page.evaluate(f"""
                            () => {{
                                const nextPageLink = document.querySelector('a[href*="page={page_num + 1}"]');
                                if (nextPageLink) {{
                                    nextPageLink.click();
                                    return "Переход на страницу {page_num + 1} выполнен";
                                }} else {{
                                    return "Ссылка на страницу {page_num + 1} не найдена";
                                }}
                            }}
                        """)
                        
                        if "выполнен" in next_page_result:
                            print(f"Переходим на страницу {page_num + 1}...")
                            await page.wait_for_timeout(3000)
                            page_num += 1
                        else:
                            print("Следующая страница не найдена, завершаем парсинг")
                            break
                    except Exception as e:
                        print(f"Ошибка при переходе на следующую страницу: {e}")
                        break
                else:
                    print("Достигнут лимит страниц, завершаем парсинг")
                    break
            
            # Сохраняем финальные результаты в JSON
            with open(f"{city_name.lower()}_final.json", "w", encoding="utf-8") as f:
                json.dump(all_organizations, f, ensure_ascii=False, indent=2)
            
            # Также сохраняем в читаемом формате
            with open(f"{city_name.lower()}_readable.txt", "w", encoding="utf-8") as f:
                f.write(f"Найдено организаций: {len(all_organizations)}\n")
                f.write(f"Обработано карточек: {total_processed_cards}\n")
                f.write(f"Процент успешных: {len(all_organizations)/total_processed_cards*100:.1f}%\n\n")
                
                for i, org in enumerate(all_organizations, 1):
                    f.write(f"{i}. {org['name']}\n")
                    f.write(f"   Адрес: {org['address']}\n")
                    f.write(f"   Рейтинг: {org['rating']} ({org['reviews']} оценок)\n")
                    if org.get('phone'):
                        f.write(f"   Телефон: {org['phone']}\n")
                    if org.get('website'):
                        f.write(f"   Сайт: {org['website']}\n")
                    f.write("\n")
            
            print(f"\nНайдено организаций: {len(all_organizations)}")
            print(f"Обработано карточек: {total_processed_cards}")
            print(f"Сохранений в файл: {saved_count}")
            print(f"Процент успешных: {len(all_organizations)/total_processed_cards*100:.1f}%" if total_processed_cards > 0 else "0%")
            print("Результаты сохранены в файлы:")
            print(f"- {city_name.lower()}.json (промежуточные данные)")
            print(f"- {city_name.lower()}_final.json (финальные данные)")
            print(f"- {city_name.lower()}_readable.txt (читаемый формат)")
            
        except Exception as e:
            print(f"Произошла ошибка: {e}")
            await page.screenshot(path="error_screenshot.png")
        
        finally:
            await page.wait_for_timeout(3000)
            await browser.close()
            print(f"🔒 Браузер закрыт для города: {city_name}")

async def extract_organization_details(page, card_text):
    """Извлекает детальную информацию об организации (УЛУЧШЕННАЯ ВЕРСИЯ)"""
    
    try:
        # Ждем загрузки детальной информации (увеличиваем время)
        await page.wait_for_timeout(5000)
        
        # Извлекаем данные с помощью JavaScript (улучшенная версия)
        org_data = await page.evaluate("""
            () => {
                const data = {
                    name: '',
                    rating: '',
                    reviews: '',
                    address: '',
                    phone: '',
                    website: ''
                };
                
                // Получаем весь текст страницы для поиска по содержимому
                const allText = document.body.textContent || document.body.innerText;
                const allHTML = document.body.innerHTML;
                
                // 1. ПОИСК НАЗВАНИЯ
                // Ищем h1 или заголовки
                const nameElements = document.querySelectorAll('h1, [class*="title"], [class*="name"]');
                for (const el of nameElements) {
                    if (el.textContent && el.textContent.trim().length > 2) {
                        data.name = el.textContent.trim();
                        break;
                    }
                }
                
                // 2. ПОИСК ТЕЛЕФОНА - УНИВЕРСАЛЬНЫЙ ПОДХОД
                // Паттерны для российских номеров
                const phonePatterns = [
                    /\\+7\\s*\\(?\\d{3}\\)?[\\s\\-]?\\d{3}[\\s\\-]?\\d{2}[\\s\\-]?\\d{2}/g,
                    /8\\s*\\(?\\d{3}\\)?[\\s\\-]?\\d{3}[\\s\\-]?\\d{2}[\\s\\-]?\\d{2}/g,
                    /\\+7[\\s\\-]?\\d{10}/g,
                    /8[\\s\\-]?\\d{10}/g
                ];
                
                for (const pattern of phonePatterns) {
                    const matches = allText.match(pattern);
                    if (matches && matches.length > 0) {
                        // Берем первый найденный номер
                        data.phone = matches[0].trim();
                        break;
                    }
                }
                
                // 3. ПОИСК САЙТА - ИЩЕМ ВСЕ ССЫЛКИ НА ВНЕШНИЕ ДОМЕНЫ
                const links = document.querySelectorAll('a[href]');
                for (const link of links) {
                    const href = link.href;
                    if (href && 
                        (href.startsWith('http://') || href.startsWith('https://')) &&
                        !href.includes('yandex.ru') && 
                        !href.includes('maps.yandex') &&
                        !href.includes('tel:') && 
                        !href.includes('mailto:') &&
                        !href.includes('google.com') &&
                        !href.includes('vk.com') &&
                        !href.includes('instagram.com') &&
                        !href.includes('facebook.com') &&
                        !href.includes('twitter.com') &&
                        !href.includes('telegram.me') &&
                        !href.includes('t.me') &&
                        !href.includes('whatsapp.com') &&
                        !href.includes('viber.com')) {
                        
                        // Извлекаем домен из URL
                        try {
                            const url = new URL(href);
                            data.website = url.hostname.replace('www.', '');
                            break;
                        } catch(e) {
                            data.website = href;
                            break;
                        }
                    }
                }
                
                // Дополнительный поиск сайта по тексту
                if (!data.website) {
                    const websitePatterns = [
                        /[a-zA-Z0-9-]+\\.(ru|com|org|net|info|biz|рф)\\b/g,
                        /www\\.[a-zA-Z0-9-]+\\.[a-zA-Z]{2,}/g
                    ];
                    
                    for (const pattern of websitePatterns) {
                        const matches = allText.match(pattern);
                        if (matches && matches.length > 0) {
                            for (const match of matches) {
                                if (!match.includes('yandex') && !match.includes('maps') && !match.includes('google')) {
                                    data.website = match.replace('www.', '');
                                    break;
                                }
                            }
                            if (data.website) break;
                        }
                    }
                }
                
                // 4. ПОИСК ОТЗЫВОВ - ИЩЕМ ЧИСЛА ПЕРЕД СЛОВОМ "ОТЗЫВ"
                const reviewPatterns = [
                    /(\\d+)\\s*отзыв/gi,
                    /(\\d+)\\s*оценк/gi,
                    /(\\d+)\\s*review/gi
                ];
                
                for (const pattern of reviewPatterns) {
                    const matches = allText.match(pattern);
                    if (matches && matches.length > 0) {
                        const reviewMatch = matches[0].match(/\\d+/);
                        if (reviewMatch) {
                            data.reviews = reviewMatch[0];
                            break;
                        }
                    }
                }
                
                // 5. ПОИСК РЕЙТИНГА
                const ratingPatterns = [
                    /рейтинг[\\s:]*([\\d,\\.]+)/gi,
                    /([\\d,\\.]+)\\s*из\\s*5/gi,
                    /([\\d,\\.]+)\\s*★/gi
                ];
                
                for (const pattern of ratingPatterns) {
                    const matches = allText.match(pattern);
                    if (matches && matches.length > 0) {
                        const ratingMatch = matches[0].match(/[\\d,\\.]+/);
                        if (ratingMatch) {
                            data.rating = ratingMatch[0].replace(',', '.');
                            break;
                        }
                    }
                }
                
                // 6. ПОИСК АДРЕСА
                const addressPatterns = [
                    /(ул\\.|улица|пр\\.|проспект|пер\\.|переулок|бул\\.|бульвар|наб\\.|набережная|ш\\.|шоссе)\\s+[А-Яа-яё\\s\\-,\\.\\d]+/gi,
                    /[А-Яа-яё\\s]+ул\\.,?\\s*[А-Яа-яё\\s\\-\\d,]+/gi,
                    /[А-Яа-яё\\s,\\-\\.\\d]+,\\s*(Липецк|Тамбов|Ульяновск|Самара|Пермь|Казань|Брянск|Белгород|Владимир|Воронеж|Иваново|Димитровград|Уфа|Екатеринбург)/gi
                ];
                
                for (const pattern of addressPatterns) {
                    const matches = allText.match(pattern);
                    if (matches && matches.length > 0) {
                        const address = matches[0].trim();
                        if (address.length > 10 && /\\d/.test(address)) {
                            data.address = address;
                            break;
                        }
                    }
                }
                
                // Логируем результаты для отладки
                console.log('Extracted data:', data);
                
                return data;
            }
        """)
        
        # Очищаем и обрабатываем данные
        name = org_data.get('name', '').strip()
        if not name and card_text:
            # Пытаемся извлечь название из карточки
            name_match = re.search(r'^([^•\n]+)', card_text)
            name = name_match.group(1).strip() if name_match else "Нет названия"
        
        rating = org_data.get('rating', '').strip()
        if not rating and card_text:
            rating_match = re.search(r'(\d+\.?\d*)', card_text)
            rating = rating_match.group(1) if rating_match else "Нет рейтинга"
        
        reviews = org_data.get('reviews', '').strip()
        if not reviews and card_text:
            reviews_match = re.search(r'(\d+)\s*оценок?', card_text)
            reviews = reviews_match.group(1) if reviews_match else "0"
        
        address = org_data.get('address', '').strip()
        phone = org_data.get('phone', '').strip()
        website = org_data.get('website', '').strip()
        
        # Дополнительная очистка данных
        if phone:
            # Нормализуем номер телефона
            phone = re.sub(r'[^\d\+\(\)\s\-]', '', phone)
            phone = phone.strip()
        
        if website:
            # Очищаем website от лишних символов
            website = website.replace('http://', '').replace('https://', '').replace('www.', '')
            website = website.split('/')[0]  # Убираем путь, оставляем только домен
        
        return {
            'name': name,
            'rating': rating,
            'reviews': reviews,
            'address': address,
            'phone': phone,
            'website': website
        }
        
    except Exception as e:
        print(f"Ошибка при извлечении данных: {e}")
        return {
            'name': "Ошибка извлечения",
            'rating': "Нет данных",
            'reviews': "0",
            'address': "Нет данных",
            'phone': "Нет данных",
            'website': "Нет данных"
        }

def read_cities_from_file(filename="cities.txt"):
    """Читает список городов из файла"""
    try:
        with open(filename, "r", encoding="utf-8") as f:
            cities = [line.strip() for line in f if line.strip()]
        return cities
    except FileNotFoundError:
        print(f"Файл {filename} не найден!")
        return []
    except Exception as e:
        print(f"Ошибка при чтении файла {filename}: {e}")
        return []

async def process_all_cities():
    """Обрабатывает все города из файла cities.txt"""
    cities = read_cities_from_file()
    
    if not cities:
        print("Список городов пуст! Проверьте файл cities.txt")
        return
    
    print(f"Найдено {len(cities)} городов для обработки:")
    for i, city in enumerate(cities, 1):
        print(f"{i}. {city}")
    
    print("\nНачинаем обработку городов...")
    
    for i, city in enumerate(cities, 1):
        print(f"\n{'='*50}")
        print(f"ОБРАБОТКА ГОРОДА {i}/{len(cities)}: {city}")
        print(f"{'='*50}")
        
        try:
            # Для каждого города запускаем отдельный процесс парсинга
            # который сам создаст новый браузер и откроет новую страницу
            await parse_yandex_maps_detailed(city)
            print(f"✅ Город {city} обработан успешно!")
        except Exception as e:
            print(f"❌ Ошибка при обработке города {city}: {e}")
            print(f"Продолжаем со следующим городом...")
        
        # Пауза между городами
        if i < len(cities):
            print(f"⏳ Пауза 10 секунд перед следующим городом...")
            await asyncio.sleep(10)

if __name__ == "__main__":
    # Для обработки одного города (например, для тестирования)
    # asyncio.run(parse_yandex_maps_detailed("Ульяновск"))
    
    # Для обработки всех городов
    asyncio.run(process_all_cities())