Раздел 1: Архитектура

middleware/
├── routes/
│   └── marketing.py           # API endpoints
├── models/
│   └── marketing.py           # SQLAlchemy models
└── services/
    └── marketing/            
        ├── __init__.py
        ├── campaign_service.py
        ├── bid_service.py
        ├── stats_service.py
        └── analytics_service.py

{
  "sku": "OM-12345",
  "marketplace": "wildberries",
  "competitors": [
    {
      "seller": "Fashion Store",
      "position": 1,
      "price": 2599,
      "estimated_bid": 150
    },
    {
      "seller": "Style Shop", 
      "position": 2,
      "price": 2499,
      "estimated_bid": 120
    }
  ],
  "our_position": 5,
  "our_price": 2450,
  "data_freshness": "2026-01-15T03:00:00Z"
}

from abc import ABC, abstractmethod
from typing import List, Optional
from dataclasses import dataclass

@dataclass
class Campaign:
    id: str
    external_id: str
    marketplace: str
    name: str
    status: str  # active, paused, archived
    campaign_type: str
    daily_budget: float
    total_budget: Optional[float]
    start_date: datetime
    end_date: Optional[datetime]
    brand_id: str

@dataclass
class Keyword:
    id: str
    campaign_id: str
    keyword: str
    match_type: str  # exact, phrase, broad
    status: str
    current_bid: float
    
@dataclass
class CampaignStats:
    campaign_id: str
    date: date
    views: int
    clicks: int
    ctr: float
    spent: float
    cpc: float
    orders: int
    revenue: float
    drr: float

class MarketplaceAdapter(ABC):
    """Базовый класс адаптера маркетплейса."""
    
    @abstractmethod
    async def get_campaigns(self, brand_id: str) -> List[Campaign]:
        """Получить список кампаний."""
        pass
    
    @abstractmethod
    async def create_campaign(self, campaign: Campaign) -> str:
        """Создать кампанию, вернуть external_id."""
        pass
    
    @abstractmethod
    async def update_campaign(self, campaign: Campaign) -> bool:
        """Обновить кампанию."""
        pass
    
    @abstractmethod
    async def pause_campaign(self, external_id: str) -> bool:
        """Приостановить кампанию."""
        pass
    
    @abstractmethod
    async def resume_campaign(self, external_id: str) -> bool:
        """Возобновить кампанию."""
        pass
    
    @abstractmethod
    async def get_keywords(self, campaign_id: str) -> List[Keyword]:
        """Получить ключевые слова кампании."""
        pass
    
    @abstractmethod
    async def add_keywords(self, campaign_id: str, keywords: List[Keyword]) -> bool:
        """Добавить ключевые слова."""
        pass
    
    @abstractmethod
    async def update_bid(self, keyword_id: str, new_bid: float) -> bool:
        """Обновить ставку."""
        pass
    
    @abstractmethod
    async def pause_keyword(self, keyword_id: str) -> bool:
        """Приостановить ключевое слово."""
        pass
    
    @abstractmethod
    async def get_stats(
        self, 
        campaign_id: str, 
        date_from: date, 
        date_to: date
    ) -> List[CampaignStats]:
        """Получить статистику кампании."""
        pass
    
    @abstractmethod
    async def get_realtime_position(self, sku: str, keyword: str) -> Optional[int]:
        """Получить текущую позицию (real-time)."""
        pass

import asyncio
from datetime import datetime, timedelta

class RateLimiter:
    """Token Bucket Rate Limiter."""
    
    def __init__(self, rate: int, per: int = 60):
        self.rate = rate  # tokens per period
        self.per = per    # period in seconds
        self.tokens = rate
        self.last_update = datetime.now()
        self._lock = asyncio.Lock()
    
    async def acquire(self):
        """Acquire a token, wait if necessary."""
        async with self._lock:
            now = datetime.now()
            elapsed = (now - self.last_update).total_seconds()
            
            # Replenish tokens
            self.tokens = min(
                self.rate,
                self.tokens + elapsed * (self.rate / self.per)
            )
            self.last_update = now
            
            if self.tokens < 1:
                wait_time = (1 - self.tokens) * (self.per / self.rate)
                await asyncio.sleep(wait_time)
                self.tokens = 0
            else:
                self.tokens -= 1

import asyncio
from functools import wraps

def with_retry(max_retries: int = 3, backoff_base: float = 2.0):
    """Декоратор для retry с exponential backoff."""
    
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            last_exception = None
            
            for attempt in range(max_retries + 1):
                try:
                    return await func(*args, **kwargs)
                except RateLimitError:
                    wait = (backoff_base ** attempt) * 10
                    await asyncio.sleep(wait)
                    last_exception = e
                except ServerError:
                    await asyncio.sleep(30)
                    last_exception = e
                except (AuthError, BadRequestError):
                    raise  # Don't retry
                    
            raise last_exception
        return wrapper
    return decorator

middleware/
├── routes/
│   └── marketing.py               # FastAPI routes
├── models/
│   └── marketing.py               # SQLAlchemy models
├── schemas/
│   └── marketing.py               # Pydantic schemas
└── services/
    └── marketing/
        ├── __init__.py
        ├── campaign_service.py    # Campaign CRUD
        ├── bid_service.py         # Bid Engine
        ├── stats_service.py       # Stats Collector
        ├── analytics_service.py   # Analytics Engine
        ├── safety_service.py      # Safety Logic
        ├── report_service.py      # Report Builder
        └── adapters/
            ├── __init__.py
            ├── base.py            # Abstract adapter
            ├── wildberries.py     # WB adapter
            ├── ozon.py            # Ozon adapter
            └── yandex_market.py   # YM adapter

tasks/
└── marketing_tasks.py             # Celery tasks

pipelines/
└── marketing_pipeline.py          # Open WebUI Pipeline

tools/
├── marketing_campaigns.py         # Campaign management tool
├── marketing_stats.py             # Stats tool
├── marketing_bids.py              # Bid management tool
└── marketing_reports.py           # Reports tool