Автоматизация работы с фото товаров: где продавец экономит время

✅ Поддерживаемые площадки: Wildberries, Ozon, Яндекс Маркет
✅ Скорость: до 50 товаров/минуту
✅ Качество: максимальное разрешение
✅ API: REST API для интеграции
✅ Стоимость: бесплатно + премиум планы

Особенности:
• Автоопределение маркетплейса по URL
• Интеллектуальные повторы при блокировках
• Экспорт в ZIP-архивы
• Batch обработка списка товаров

✅ Специализация: только Wildberries
✅ Скорость: 20-30 товаров/минуту
✅ Особенности: работа по артикулам
✅ Стоимость: 5 товаров/день бесплатно

Ограничения:
• Только один маркетплейс
• Ограниченный функционал в бесплатной версии

✅ Специализация: Wildberries
✅ Формат: 900x1200px
✅ Демо-версия: до 5 товаров бесплатно
✅ Batch режим: в платной версии

Минусы:
• Устаревший интерфейс
• Частые ошибки при высокой нагрузке

## Пример работы с WB Suppliers API
import requests

class WildberriesAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://suppliers-api.wildberries.ru"

    def get_product_images(self, vendor_code):
        """Получение изображений товара через официальный API."""
        headers = {
            'Authorization': f'Bearer {self.api_key}',
            'Content-Type': 'application/json'
        }
## Получаем информацию о товаре
        product_url = f"{self.base_url}/card/list"
        params = {'vendorCode': vendor_code}

        response = requests.get(product_url, headers=headers, params=params)

        if response.status_code == 200:
            data = response.json()
            product = data.get('cards', [{}])[0]
## Извлекаем URL изображений
            images = []
            for photo in product.get('photos', []):
## Строим URL изображения высокого качества
                photo_id = photo.get('big')
                if photo_id:
                    img_url = f"https://images.wbstatic.net/big/new/{photo_id}.jpg"
                    images.append(img_url)

            return images

        return []
## Использование
wb_api = WildberriesAPI('your-api-key')
images = wb_api.get_product_images('YOUR_VENDOR_CODE')

class OzonAPI:
    def __init__(self, client_id, api_key):
        self.client_id = client_id
        self.api_key = api_key
        self.base_url = "https://api-seller.ozon.ru"

    def get_product_info(self, product_id):
        """Получение информации о товаре включая изображения."""
        headers = {
            'Client-Id': self.client_id,
            'Api-Key': self.api_key,
            'Content-Type': 'application/json'
        }

        payload = {
            "product_id": product_id,
            "offer_id": "",
            "sku": ""
        }

        response = requests.post(
            f"{self.base_url}/v2/product/info", 
            json=payload, 
            headers=headers
        )

        if response.status_code == 200:
            data = response.json()
            result = data.get('result', {})
## Получаем все изображения
            images = []
            for image in result.get('images', []):
## Конвертируем в максимальное качество
                if 'cdn1.ozone.ru' in image:
                    high_res = image.replace('/wc250/', '/wc1200/')
                    images.append(high_res)
                else:
                    images.append(image)

            return images

        return []

## Пример Scrapy spider для маркетплейсов
import scrapy
from urllib.parse import urljoin
import re

class MarketplaceSpider(scrapy.Spider):
    name = 'marketplace_images'

    custom_settings = {
        'ROBOTSTXT_OBEY': False,
        'DOWNLOAD_DELAY': 1,
        'RANDOMIZE_DOWNLOAD_DELAY': True,
        'CONCURRENT_REQUESTS': 5,
        'USER_AGENT': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0'
    }

    def parse(self, response):
        """Парсинг страницы товара."""
## Определяем маркетплейс
        if 'wildberries.ru' in response.url:
            yield from self.parse_wildberries(response)
        elif 'ozon.ru' in response.url:
            yield from self.parse_ozon(response)
        elif 'market.yandex.ru' in response.url:
            yield from self.parse_yandex(response)

    def parse_wildberries(self, response):
        """Парсинг товара Wildberries."""
## Извлекаем ID товара из URL
        product_id_match = re.search(r'/catalog/(\d+)/', response.url)
        if not product_id_match:
            return

        product_id = int(product_id_match.group(1))
## Генерируем URL изображений по алгоритму WB
        vol = product_id // 100000
        part = product_id // 1000
## Пробуем разные сервера CDN
        for server in range(1, 19):
            api_url = f"https://basket-{server:02d}.wbbasket.ru/vol{vol}/part{part}/{product_id}/info/ru/card.json"

            yield scrapy.Request(
                api_url,
                callback=self.parse_wb_api_response,
                meta={
                    'product_id': product_id,
                    'server': server,
                    'vol': vol,
                    'part': part
                },
                dont_filter=True
            )

            break  # Берем первый доступный сервер

    def parse_wb_api_response(self, response):
        """Обработка API ответа Wildberries."""

        if response.status == 200:
            try:
                data = response.json()
                photo_count = data.get('photo_count', 1)

                meta = response.meta
                product_id = meta['product_id']
                server = meta['server']
                vol = meta['vol']
                part = meta['part']
## Генерируем URL всех изображений
                images = []
                for i in range(1, photo_count + 1):
                    img_url = f"https://basket-{server:02d}.wbbasket.ru/vol{vol}/part{part}/{product_id}/images/big/{i}.webp"
                    images.append(img_url)

                yield {
                    'product_id': product_id,
                    'marketplace': 'wildberries',
                    'images': images,
                    'total_images': len(images)
                }

            except Exception as e:
                self.logger.error(f"Error parsing WB API response: {e}")
## Запуск spider
## scrapy crawl marketplace_images -a start_urls="https://www.wildberries.ru/catalog/123456/detail.aspx"

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import undetected_chromedriver as uc
import time
import random

class UndetectedMarketplaceScraper:
    def __init__(self):
        self.setup_driver()

    def setup_driver(self):
        """Настройка браузера с обходом детекции."""

        options = uc.ChromeOptions()
## Stealth настройки
        options.add_argument('--disable-web-security')
        options.add_argument('--disable-features=VizDisplayCompositor')
        options.add_argument('--disable-extensions')
        options.add_argument('--no-sandbox')
        options.add_argument('--disable-dev-shm-usage')
## Имитация реального пользователя
        options.add_argument('--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')

        self.driver = uc.Chrome(options=options)
## Изменяем отпечаток браузера
        self.driver.execute_cdp_cmd('Network.setUserAgentOverride', {
            "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        })
## Блокируем изображения для экономии трафика (получаем только URL)
        prefs = {"profile.managed_default_content_settings.images": 2}
        options.add_experimental_option("prefs", prefs)

    def scrape_ozon_realistic(self, product_url):
        """Реалистичный скрапинг Ozon с обходом защиты."""

        try:
## Имитируем реального пользователя - заходим сначала на главную
            self.driver.get("https://www.ozon.ru")
            self.human_like_wait(2, 4)
## Скроллим немного на главной
            self.driver.execute_script("window.scrollTo(0, 500);")
            self.human_like_wait(1, 2)
## Переходим на товар
            self.driver.get(product_url)
            self.human_like_wait(3, 6)
## Ждем загрузки галереи
            wait = WebDriverWait(self.driver, 10)
            gallery = wait.until(
                EC.presence_of_element_located((By.CSS_SELECTOR, '[data-widget="webGallery"]'))
            )
## Имитируем пролистывание фотографий
            images = []
            thumbnails = self.driver.find_elements(By.CSS_SELECTOR, '[data-widget="webGallery"] img')

            for i, thumbnail in enumerate(thumbnails):
                try:
## Кликаем на превью (как реальный пользователь)
                    self.driver.execute_script("arguments[0].click();", thumbnail)
                    self.human_like_wait(0.5, 1.5)
## Получаем URL основного изображения
                    main_img = self.driver.find_element(By.CSS_SELECTOR, '[data-widget="webGallery"] [data-state="active"] img')
                    img_src = main_img.get_attribute('src')

                    if img_src and 'cdn1.ozone.ru' in img_src:
## Конвертируем в максимальное качество
                        high_res_url = img_src.replace('/wc250/', '/wc1200/')
                        images.append(high_res_url)

                except Exception as e:
                    print(f"Error processing image {i}: {e}")
                    continue

            return list(set(images))  # Убираем дубликаты

        except Exception as e:
            print(f"Error scraping Ozon: {e}")
            return []

    def human_like_wait(self, min_sec, max_sec):
        """Человекоподобные паузы."""
        wait_time = random.uniform(min_sec, max_sec)
        time.sleep(wait_time)

    def __del__(self):
        if hasattr(self, 'driver'):
            self.driver.quit()
## Использование
scraper = UndetectedMarketplaceScraper()
ozon_images = scraper.scrape_ozon_realistic("https://www.ozon.ru/product/example-123456")
print(f"Found {len(ozon_images)} images")

import subprocess
import os
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
import logging

class ImageProcessor:
    """Массовая обработка изображений с помощью ImageMagick."""

    def __init__(self):
        self.logger = logging.getLogger(__name__)
## Проверяем наличие ImageMagick
        try:
            subprocess.run(['magick', '-version'], capture_output=True, check=True)
            self.magick_available = True
        except (subprocess.CalledProcessError, FileNotFoundError):
            self.logger.warning("ImageMagick not found. Install it for better performance.")
            self.magick_available = False

    def resize_for_marketplace(self, input_dir, output_dir, marketplace='wildberries'):
        """Подготовка изображений для конкретного маркетплейса."""
## Настройки для разных маркетплейсов
        settings = {
            'wildberries': {
                'size': '1200x1600',
                'quality': '90',
                'format': 'webp'
            },
            'ozon': {
                'size': '1200x1200',
                'quality': '85', 
                'format': 'jpeg'
            },
            'yandex': {
                'size': '1000x1000',
                'quality': '90',
                'format': 'jpeg'
            }
        }

        config = settings.get(marketplace, settings['wildberries'])

        if not os.path.exists(output_dir):
            os.makedirs(output_dir)
## Получаем список файлов
        input_path = Path(input_dir)
        image_files = list(input_path.glob('*.jpg')) + list(input_path.glob('*.png'))
## Обрабатываем параллельно
        with ThreadPoolExecutor(max_workers=4) as executor:
            futures = []
            for img_file in image_files:
                future = executor.submit(
                    self._process_single_image, 
                    img_file, 
                    output_dir, 
                    config
                )
                futures.append(future)
## Собираем результаты
            for i, future in enumerate(futures):
                try:
                    result = future.result()
                    if result:
                        self.logger.info(f"Processed {i+1}/{len(futures)}: {result}")
                except Exception as e:
                    self.logger.error(f"Error processing image {i+1}: {e}")

    def _process_single_image(self, input_file, output_dir, config):
        """Обработка одного изображения."""

        output_file = os.path.join(
            output_dir, 
            f"{input_file.stem}_optimized.{config['format']}"
        )

        if self.magick_available:
## Используем ImageMagick для лучшего качества
            cmd = [
                'magick', str(input_file),
                '-resize', config['size'] + '^',
                '-gravity', 'center',
                '-extent', config['size'],
                '-quality', config['quality'],
                '-strip',  # Удаляем метаданные
                output_file
            ]

            try:
                subprocess.run(cmd, check=True, capture_output=True)
                return output_file
            except subprocess.CalledProcessError as e:
                self.logger.error(f"ImageMagick error: {e}")
                return None
        else:
## Fallback на PIL
            return self._process_with_pil(input_file, output_file, config)

    def _process_with_pil(self, input_file, output_file, config):
        """Обработка с помощью PIL."""
        from PIL import Image, ImageOps

        try:
            with Image.open(input_file) as img:
## Конвертируем в RGB если нужно
                if img.mode in ('RGBA', 'LA', 'P'):
                    img = img.convert('RGB')
## Изменяем размер с сохранением пропорций
                target_size = tuple(map(int, config['size'].split('x')))
                img = ImageOps.fit(img, target_size, Image.Resampling.LANCZOS)
## Сохраняем
                save_kwargs = {
                    'optimize': True,
                    'quality': int(config['quality'])
                }

                if config['format'].lower() == 'webp':
                    save_kwargs['method'] = 6  # Лучшее сжатие WebP

                img.save(output_file, config['format'].upper(), **save_kwargs)

                return output_file

        except Exception as e:
            self.logger.error(f"PIL error processing {input_file}: {e}")
            return None
## Пример использования
processor = ImageProcessor()
processor.resize_for_marketplace('./raw_images', './processed_wb', 'wildberries')

import requests
import os

class BackgroundRemover:
    """Автоматическое удаление фона с помощью Remove.bg API."""

    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.remove.bg/v1.0/removebg"

    def remove_background_batch(self, input_dir, output_dir):
        """Пакетное удаление фона."""

        if not os.path.exists(output_dir):
            os.makedirs(output_dir)

        for filename in os.listdir(input_dir):
            if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
                input_path = os.path.join(input_dir, filename)
                output_path = os.path.join(output_dir, f"nobg_{filename}")

                try:
                    self.remove_background_single(input_path, output_path)
                    print(f"✅ Processed: {filename}")
                except Exception as e:
                    print(f"❌ Error processing {filename}: {e}")

    def remove_background_single(self, input_path, output_path):
        """Удаление фона одного изображения."""

        with open(input_path, 'rb') as img_file:
            response = requests.post(
                self.base_url,
                files={'image_file': img_file},
                data={'size': 'auto'},
                headers={'X-Api-Key': self.api_key}
            )

        if response.status_code == 200:
            with open(output_path, 'wb') as out_file:
                out_file.write(response.content)
        else:
            raise Exception(f"API error: {response.status_code} - {response.text}")
## Использование
bg_remover = BackgroundRemover('your-remove-bg-api-key')
bg_remover.remove_background_batch('./product_images', './no_background')

class OneC_MarketplaceIntegration:
    """Интеграция с 1С для автоматического обмена изображениями."""

    def __init__(self, onec_connection_string):
        self.connection_string = onec_connection_string

    def sync_images_from_onec(self):
        """Синхронизация изображений из базы 1С."""
## Подключение к базе 1С через COM
        import win32com.client

        try:
## Создаем подключение к 1С
            onec_app = win32com.client.Dispatch("V83.COMConnector")
            connection = onec_app.Connect(self.connection_string)
## Запрос товаров с изображениями
            query = """
            ВЫБРАТЬ
                Номенклатура.Код КАК Код,
                Номенклатура.Наименование КАК Наименование,
                Номенклатура.Изображение КАК Изображение,
                Номенклатура.АртикулWB КАК АртикулWB,
                Номенклатура.АртикулOzon КАК АртикулOzon
            ИЗ
                Справочник.Номенклатура КАК Номенклатура
            ГДЕ
                Номенклатура.Изображение <> ЗНАЧЕНИЕ(Хранилище.ДвоичныеДанные.ПустаяСсылка)
            """

            result = connection.Execute(query)

            products_to_sync = []
            while not result.EOF():
                product = {
                    'code': result.Fields('Код').Value,
                    'name': result.Fields('Наименование').Value,
                    'wb_article': result.Fields('АртикулWB').Value,
                    'ozon_article': result.Fields('АртикулOzon').Value,
                    'image_data': result.Fields('Изображение').Value
                }

                products_to_sync.append(product)
                result.MoveNext()

            return products_to_sync

        except Exception as e:
            print(f"Error connecting to 1C: {e}")
            return []

    def upload_images_to_marketplaces(self, products):
        """Загрузка изображений на маркетплейсы."""

        for product in products:
## Сохраняем изображение из 1С во временный файл
            temp_image_path = f"./temp/{product['code']}.jpg"

            with open(temp_image_path, 'wb') as f:
                f.write(product['image_data'])
## Загружаем на Wildberries
            if product['wb_article']:
                self.upload_to_wildberries(product['wb_article'], temp_image_path)
## Загружаем на Ozon
            if product['ozon_article']:
                self.upload_to_ozon(product['ozon_article'], temp_image_path)
## Удаляем временный файл
            os.remove(temp_image_path)

    def upload_to_wildberries(self, article, image_path):
        """Загрузка изображения на Wildberries через API."""
## Реализация загрузки через WB Suppliers API
        pass

    def upload_to_ozon(self, article, image_path):
        """Загрузка изображения на Ozon через API."""
## Реализация загрузки через Ozon Seller API
        pass

import schedule
import time
from datetime import datetime
import sqlite3
import hashlib

class CompetitorImageMonitor:
    """Автоматический мониторинг изменений изображений у конкурентов."""

    def __init__(self, db_path='competitor_monitor.db'):
        self.db_path = db_path
        self.init_database()

    def init_database(self):
        """Инициализация базы данных для хранения истории."""
        conn = sqlite3.connect(self.db_path)

        conn.execute('''
            CREATE TABLE IF NOT EXISTS product_snapshots (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                competitor_name TEXT NOT NULL,
                product_url TEXT NOT NULL,
                image_count INTEGER,
                image_hashes TEXT, -- JSON array of image hashes
                snapshot_date DATETIME DEFAULT CURRENT_TIMESTAMP,
                changes_detected BOOLEAN DEFAULT FALSE
            )
        ''')

        conn.execute('''
            CREATE TABLE IF NOT EXISTS image_changes (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                product_url TEXT NOT NULL,
                change_type TEXT, -- 'added', 'removed', 'modified'
                old_hash TEXT,
                new_hash TEXT,
                change_date DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')

        conn.commit()
        conn.close()

    def add_competitor_product(self, competitor_name, product_url):
        """Добавление товара конкурента для мониторинга."""

        conn = sqlite3.connect(self.db_path)
## Проверяем, не отслеживается ли уже этот товар
        existing = conn.execute(
            "SELECT id FROM product_snapshots WHERE product_url = ? ORDER BY snapshot_date DESC LIMIT 1",
            (product_url,)
        ).fetchone()

        if not existing:
## Делаем первичный снимок
            snapshot = self.take_product_snapshot(competitor_name, product_url)
            if snapshot:
                conn.execute('''
                    INSERT INTO product_snapshots 
                    (competitor_name, product_url, image_count, image_hashes)
                    VALUES (?, ?, ?, ?)
                ''', snapshot)

                conn.commit()

        conn.close()

    def take_product_snapshot(self, competitor_name, product_url):
        """Создание снимка товара (получение всех изображений)."""

        try:
## Используем наш MarketScraper для получения изображений
            scraper = MarketplaceScraper()
            images = scraper.scrape_images(product_url)

            if not images:
                return None
## Вычисляем хеши изображений для отслеживания изменений
            image_hashes = []
            for img_url in images:
## Скачиваем изображение
                response = requests.get(img_url)
                if response.status_code == 200:
## Вычисляем MD5 хеш содержимого
                    img_hash = hashlib.md5(response.content).hexdigest()
                    image_hashes.append(img_hash)

            return (
                competitor_name,
                product_url,
                len(images),
                json.dumps(image_hashes)
            )

        except Exception as e:
            print(f"Error taking snapshot of {product_url}: {e}")
            return None

    def check_for_changes(self):
        """Проверка всех отслеживаемых товаров на изменения."""

        conn = sqlite3.connect(self.db_path)
## Получаем список последних снимков всех товаров
        products = conn.execute('''
            SELECT competitor_name, product_url, image_hashes
            FROM product_snapshots s1
            WHERE snapshot_date = (
                SELECT MAX(snapshot_date) 
                FROM product_snapshots s2 
                WHERE s2.product_url = s1.product_url
            )
        ''').fetchall()

        changes_found = []

        for competitor_name, product_url, old_hashes_json in products:
            try:
## Делаем новый снимок
                new_snapshot = self.take_product_snapshot(competitor_name, product_url)

                if new_snapshot:
                    old_hashes = set(json.loads(old_hashes_json))
                    new_hashes = set(json.loads(new_snapshot[3]))
## Сравниваем хеши
                    added_images = new_hashes - old_hashes
                    removed_images = old_hashes - new_hashes

                    if added_images or removed_images:
## Обнаружены изменения
                        changes_found.append({
                            'competitor': competitor_name,
                            'url': product_url,
                            'added_count': len(added_images),
                            'removed_count': len(removed_images)
                        })
## Сохраняем новый снимок
                        conn.execute('''
                            INSERT INTO product_snapshots 
                            (competitor_name, product_url, image_count, image_hashes, changes_detected)
                            VALUES (?, ?, ?, ?, ?)
                        ''', new_snapshot + (True,))
## Логируем изменения
                        for img_hash in added_images:
                            conn.execute('''
                                INSERT INTO image_changes (product_url, change_type, new_hash)
                                VALUES (?, ?, ?)
                            ''', (product_url, 'added', img_hash))

                        for img_hash in removed_images:
                            conn.execute('''
                                INSERT INTO image_changes (product_url, change_type, old_hash)
                                VALUES (?, ?, ?)
                            ''', (product_url, 'removed', img_hash))

            except Exception as e:
                print(f"Error checking {product_url}: {e}")
                continue

        conn.commit()
        conn.close()

        if changes_found:
            self.send_change_notification(changes_found)

        return changes_found

    def send_change_notification(self, changes):
        """Отправка уведомления об изменениях."""

        message = f"🔔 Обнаружены изменения в {len(changes)} товарах конкурентов:\n\n"

        for change in changes:
            message += f"• {change['competitor']}\n"
            message += f"  Добавлено фото: {change['added_count']}\n"
            message += f"  Удалено фото: {change['removed_count']}\n"
            message += f"  URL: {change['url'][:60]}...\n\n"
## Здесь можно добавить отправку в Telegram, email, Slack и т.д.
        print(message)

    def start_monitoring(self, check_interval_hours=24):
        """Запуск автоматического мониторинга."""
## Планируем периодические проверки
        schedule.every(check_interval_hours).hours.do(self.check_for_changes)

        print(f"🤖 Мониторинг запущен. Проверка каждые {check_interval_hours} часов.")

        while True:
            schedule.run_pending()
            time.sleep(3600)  # Проверяем расписание каждый час
## Использование
monitor = CompetitorImageMonitor()
## Добавляем товары конкурентов
monitor.add_competitor_product("Конкурент А", "https://www.wildberries.ru/catalog/123456/detail.aspx")
monitor.add_competitor_product("Конкурент Б", "https://www.ozon.ru/product/example-789012/")
## Запускаем мониторинг
monitor.start_monitoring(check_interval_hours=12)

✅ Функции:
• Мониторинг цен и наличия
• Отслеживание изменений изображений
• Анализ конкурентов
• API для интеграции

💰 Стоимость: от 15,000₽/месяц
🎯 Для кого: средний и крупный бизнес

✅ Функции:
• Оптимизация фидов для маркетплейсов
• Автоматическая обработка изображений
• A/B тестирование товарных карточек
• Интеграция с 50+ площадками

💰 Стоимость: от $299/месяц
🎯 Для кого: международные продавцы

✅ Функции:
• Мониторинг позиций на маркетплейсах
• Анализ конкурентов и их изображений
• Автоматическое изменение цен
• Российская поддержка

💰 Стоимость: от 5,000₽/месяц
🎯 Для кого: российские продавцы

class MarketplaceImagePipeline:
    """Комплексный пайплайн обработки изображений товаров."""

    def __init__(self, config_path='pipeline_config.yaml'):
        self.config = self.load_config(config_path)
        self.setup_logging()

    def load_config(self, config_path):
        """Загрузка конфигурации пайплайна."""
        import yaml

        default_config = {
            'scrapers': {
                'wildberries': {'enabled': True, 'delay': 1},
                'ozon': {'enabled': True, 'delay': 2}, 
                'yandex': {'enabled': True, 'delay': 1}
            },
            'processing': {
                'resize': True,
                'remove_background': False,
                'add_watermark': False,
                'optimize_compression': True
            },
            'output': {
                'formats': ['webp', 'jpg'],
                'quality': 85,
                'max_size_mb': 2
            },
            'monitoring': {
                'check_interval_hours': 24,
                'notify_changes': True
            }
        }

        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                config = yaml.safe_load(f)
                return {**default_config, **config}
        except FileNotFoundError:
## Создаем файл конфигурации по умолчанию
            with open(config_path, 'w', encoding='utf-8') as f:
                yaml.dump(default_config, f, default_flow_style=False, allow_unicode=True)
            return default_config

    def setup_logging(self):
        """Настройка логирования."""
        import logging
        from logging.handlers import RotatingFileHandler
## Создаем logger
        self.logger = logging.getLogger('ImagePipeline')
        self.logger.setLevel(logging.INFO)
## Формат логов
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
## Ротируемый файловый handler
        file_handler = RotatingFileHandler(
            'pipeline.log', 
            maxBytes=10*1024*1024,  # 10MB
            backupCount=5
        )
        file_handler.setFormatter(formatter)
        file_handler.setLevel(logging.INFO)
## Консольный handler
        console_handler = logging.StreamHandler()
        console_handler.setFormatter(formatter)
        console_handler.setLevel(logging.INFO)
## Добавляем handlers
        self.logger.addHandler(file_handler)
        self.logger.addHandler(console_handler)

    def run_pipeline(self, input_urls, output_dir):
        """Запуск полного пайплайна обработки."""

        self.logger.info(f"Starting pipeline for {len(input_urls)} URLs")

        results = {
            'successful': 0,
            'failed': 0,
            'total_images': 0,
            'errors': []
        }

        for i, url in enumerate(input_urls):
            try:
                self.logger.info(f"Processing {i+1}/{len(input_urls)}: {url}")
## Шаг 1: Скрапинг изображений
                images = self.scrape_images(url)
                if not images:
                    results['errors'].append(f"No images found for {url}")
                    results['failed'] += 1
                    continue
## Шаг 2: Скачивание
                downloaded_images = self.download_images(images, output_dir)
## Шаг 3: Обработка
                processed_images = self.process_images(downloaded_images, output_dir)
## Шаг 4: Оптимизация
                optimized_images = self.optimize_images(processed_images, output_dir)

                results['successful'] += 1
                results['total_images'] += len(optimized_images)

                self.logger.info(f"✅ Successfully processed {len(optimized_images)} images from {url}")

            except Exception as e:
                self.logger.error(f"❌ Error processing {url}: {e}")
                results['failed'] += 1
                results['errors'].append(str(e))
## Финальный отчет
        self.logger.info(f"""
        Pipeline completed:
        ✅ Successful: {results['successful']}
        ❌ Failed: {results['failed']}
        📸 Total images: {results['total_images']}
        """)

        return results

    def scrape_images(self, url):
        """Скрапинг изображений с учетом настроек."""
## Используем наш универсальный скрапер
        scraper = MarketplaceScraper()
        return scraper.scrape_images(url)

    def download_images(self, image_urls, output_dir):
        """Скачивание изображений."""
        downloaded = []

        for i, img_url in enumerate(image_urls):
            try:
                response = requests.get(img_url, timeout=30)
                if response.status_code == 200:
## Генерируем имя файла
                    file_extension = img_url.split('.')[-1].lower()
                    if file_extension not in ['jpg', 'jpeg', 'png', 'webp']:
                        file_extension = 'jpg'

                    filename = f"image_{i+1:03d}.{file_extension}"
                    filepath = os.path.join(output_dir, filename)

                    with open(filepath, 'wb') as f:
                        f.write(response.content)

                    downloaded.append(filepath)

            except Exception as e:
                self.logger.warning(f"Failed to download {img_url}: {e}")

        return downloaded

    def process_images(self, image_paths, output_dir):
        """Обработка изображений согласно конфигурации."""
        processed = []

        processing_config = self.config['processing']

        for img_path in image_paths:
            try:
                result_path = img_path
## Изменение размера
                if processing_config.get('resize'):
                    result_path = self.resize_image(result_path, output_dir)
## Удаление фона
                if processing_config.get('remove_background'):
                    result_path = self.remove_background(result_path, output_dir)
## Добавление водяного знака
                if processing_config.get('add_watermark'):
                    result_path = self.add_watermark(result_path, output_dir)

                processed.append(result_path)

            except Exception as e:
                self.logger.warning(f"Failed to process {img_path}: {e}")

        return processed

    def optimize_images(self, image_paths, output_dir):
        """Оптимизация изображений."""
        optimized = []
        output_config = self.config['output']

        for img_path in image_paths:
            try:
## Конвертируем в нужные форматы
                for format_name in output_config['formats']:
                    optimized_path = self.convert_and_optimize(
                        img_path, 
                        output_dir, 
                        format_name,
                        output_config['quality']
                    )
                    optimized.append(optimized_path)

            except Exception as e:
                self.logger.warning(f"Failed to optimize {img_path}: {e}")

        return optimized
## Создание конфигурационного файла
pipeline_config = """
scrapers:
  wildberries:
    enabled: true
    delay: 1
  ozon:
    enabled: true
    delay: 2
  yandex:
    enabled: true
    delay: 1

processing:
  resize: true
  remove_background: false
  add_watermark: false
  optimize_compression: true

output:
  formats: ['webp', 'jpg']
  quality: 85
  max_size_mb: 2

monitoring:
  check_interval_hours: 24
  notify_changes: true
"""
## Использование
pipeline = MarketplaceImagePipeline()

urls = [
    'https://www.wildberries.ru/catalog/123456/detail.aspx',
    'https://www.ozon.ru/product/example-789012/',
    'https://market.yandex.ru/product/345678'
]

results = pipeline.run_pipeline(urls, './processed_images')

class AutomationROICalculator:
    """Калькулятор ROI от внедрения автоматизации."""

    def __init__(self):
        self.hourly_rate = 1000  # Средняя стоимость часа работы специалиста

    def calculate_manual_costs(self, products_count, images_per_product=8):
        """Расчет затрат на ручную обработку."""
## Время на ручную обработку (в часах)
        time_breakdown = {
            'search_and_download': products_count * images_per_product * 0.02,  # 1.2 мин на фото
            'resize_and_optimize': products_count * images_per_product * 0.01,  # 0.6 мин на фото  
            'upload_to_marketplace': products_count * 0.1,  # 6 мин на товар
            'quality_control': products_count * 0.05  # 3 мин на товар
        }

        total_hours = sum(time_breakdown.values())
        total_cost = total_hours * self.hourly_rate

        return {
            'total_hours': total_hours,
            'total_cost': total_cost,
            'cost_per_product': total_cost / products_count,
            'breakdown': time_breakdown
        }

    def calculate_automation_costs(self, products_count, solution_type='custom'):
        """Расчет затрат на автоматизированную обработку."""
## Варианты автоматизации
        solutions = {
            'free_tools': {
                'setup_cost': 0,
                'monthly_cost': 0,
                'time_savings': 0.8  # 80% экономии времени
            },
            'saas_subscription': {
                'setup_cost': 50000,
                'monthly_cost': 15000,
                'time_savings': 0.9  # 90% экономии времени
            },
            'custom_development': {
                'setup_cost': 300000,
                'monthly_cost': 5000,  # Поддержка
                'time_savings': 0.95  # 95% экономии времени
            }
        }

        solution = solutions.get(solution_type, solutions['custom_development'])
## Расчет остаточного ручного труда
        manual_costs = self.calculate_manual_costs(products_count)
        remaining_manual_cost = manual_costs['total_cost'] * (1 - solution['time_savings'])

        return {
            'setup_cost': solution['setup_cost'],
            'monthly_operational_cost': solution['monthly_cost'] + remaining_manual_cost,
            'time_savings_percent': solution['time_savings'] * 100,
            'remaining_manual_hours': manual_costs['total_hours'] * (1 - solution['time_savings'])
        }

    def calculate_payback_period(self, products_count, solution_type='custom', months=12):
        """Расчет срока окупаемости автоматизации."""

        manual_costs = self.calculate_manual_costs(products_count)
        automation_costs = self.calculate_automation_costs(products_count, solution_type)
## Ежемесячная экономия
        monthly_savings = manual_costs['total_cost'] - automation_costs['monthly_operational_cost']
## Срок окупаемости (в месяцах)
        if monthly_savings > 0:
            payback_months = automation_costs['setup_cost'] / monthly_savings
        else:
            payback_months = float('inf')
## Экономия за период
        total_savings_period = (monthly_savings * months) - automation_costs['setup_cost']

        return {
            'monthly_manual_cost': manual_costs['total_cost'],
            'monthly_automation_cost': automation_costs['monthly_operational_cost'],
            'monthly_savings': monthly_savings,
            'payback_months': payback_months,
            'total_savings_12months': total_savings_period,
            'roi_percent': (total_savings_period / automation_costs['setup_cost']) * 100 if automation_costs['setup_cost'] > 0 else float('inf')
        }

    def generate_report(self, products_count, solution_type='custom'):
        """Генерация подробного отчета по ROI."""

        analysis = self.calculate_payback_period(products_count, solution_type)

        report = f"""
        📊 АНАЛИЗ ROI АВТОМАТИЗАЦИИ
        =============================

        🛍️ Количество товаров: {products_count:,}
        🔧 Тип решения: {solution_type}

        💰 ФИНАНСОВЫЕ ПОКАЗАТЕЛИ:
        • Ручная обработка: {analysis['monthly_manual_cost']:,.0f} ₽/мес
        • Автоматизация: {analysis['monthly_automation_cost']:,.0f} ₽/мес
        • Экономия в месяц: {analysis['monthly_savings']:,.0f} ₽

        📈 ЭФФЕКТИВНОСТЬ:
        • Срок окупаемости: {analysis['payback_months']:.1f} месяцев
        • ROI за 12 месяцев: {analysis['roi_percent']:,.0f}%
        • Итоговая экономия: {analysis['total_savings_12months']:,.0f} ₽

        📊 РЕКОМЕНДАЦИЯ:
        """

        if analysis['payback_months'] <= 6:
            report += "🟢 Автоматизация высокоэффективна - внедряйте немедленно!"
        elif analysis['payback_months'] <= 12:
            report += "🟡 Автоматизация целесообразна - планируйте внедрение"
        else:
            report += "🔴 Автоматизация нецелесообразна при текущих объемах"

        return report
## Пример использования
roi_calc = AutomationROICalculator()
## Анализ для разных объемов бизнеса
print("=== МАЛЫЙ БИЗНЕС (100 товаров) ===")
print(roi_calc.generate_report(100, 'free_tools'))

print("\n=== СРЕДНИЙ БИЗНЕС (1000 товаров) ===") 
print(roi_calc.generate_report(1000, 'saas_subscription'))

print("\n=== КРУПНЫЙ БИЗНЕС (10000 товаров) ===")
print(roi_calc.generate_report(10000, 'custom_development'))

🔍 Анализ существующих процессов:
[ ] Подсчет времени на ручные операции
[ ] Выявление узких мест
[ ] Оценка качества текущих изображений
[ ] Анализ ошибок и переделок

📊 Сбор метрик:
[ ] Среднее время обработки товара
[ ] Стоимость обработки за месяц
[ ] Количество ошибок
[ ] Удовлетворенность качеством

🛠️ Критерии выбора:
[ ] Соответствие объемам бизнеса
[ ] Интеграция с существующими системами
[ ] Техническая сложность внедрения
[ ] Стоимость владения
[ ] Возможности масштабирования

🎯 Пилотное тестирование:
[ ] Выбор 10-20 товаров для теста
[ ] Сравнение качества с ручной работой
[ ] Измерение времени обработки
[ ] Оценка удобства использования

🚀 Поэтапный запуск:
[ ] Настройка инструментов
[ ] Обучение команды
[ ] Отладка процессов
[ ] Настройка мониторинга

📈 Контроль качества:
[ ] Ежедневная проверка результатов
[ ] Корректировка параметров
[ ] Создание регламентов
[ ] Резервные планы

⚡ Непрерывное улучшение:
[ ] Анализ эффективности
[ ] A/B тестирование настроек
[ ] Обратная связь от пользователей
[ ] Обновление инструментов

📊 Мониторинг результатов:
[ ] Еженедельные отчеты по KPI
[ ] Сравнение с плановыми показателями
[ ] Выявление новых возможностей
[ ] Планирование развития