# AI-сегментация клиентов: RFM + KMeans
pip install pandas scikit-learn

import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Загрузка транзакций из CRM-выгрузки
df = pd.read_csv("transactions.csv", parse_dates=["date"])

# RFM-метрики на сегодня
now = pd.Timestamp.now()
rfm = df.groupby("customer_id").agg(
    recency=("date", lambda x: (now - x.max()).days),
    frequency=("order_id", "nunique"),
    monetary=("amount", "sum")
).reset_index()

# Нормализация и кластеризация (4 сегмента)
X = StandardScaler().fit_transform(rfm[["recency", "frequency", "monetary"]])
rfm["segment"] = KMeans(n_clusters=4, random_state=42).fit_predict(X)

# Интерпретация сегментов
seg_map = {
    0: "VIP",
    1: "Спящие",
    2: "Новые перспективные",
    3: "Уходящие"
}
rfm["segment_name"] = rfm["segment"].map(seg_map)

print(rfm.groupby("segment_name").size())
# VIP: 142 | Спящие: 891 | Новые: 340 | Уходящие: 267
# Каждому сегменту — свой тип рассылки!

# Генерация персонализированного письма через Claude API
import anthropic

client = anthropic.Anthropic(api_key="YOUR_KEY")

def generate_email(customer: dict, campaign: dict) -> dict:
    prompt = f"""Ты — email-маркетолог. Напиши персонализированное письмо.

Профиль клиента:
- Имя: {customer['name']}
- Сегмент: {customer['segment']}
- Последняя покупка: {customer['last_purchase']}
- Интересы: {customer['interests']}

Кампания: {campaign['name']}
Оффер: {campaign['offer']}
Тон: {campaign.get('tone', 'дружелюбный профессиональный')}

Сгенерируй письмо и верни строгий JSON:
{{
  "subject": "тема письма (30-50 символов, цепляющая)",
  "preheader": "прехедер (40-80 символов)",
  "body_html": "HTML письма (адаптивный, тёмная тема НЕ нужна)",
  "cta_text": "текст кнопки",
  "cta_url": "https://example.com/offer?utm=...",
  "sender_name": "Имя отправителя"
}}
Пиши на русском. Только JSON."""

    resp = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        temperature=0.7,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(resp.content[0].text)

# Генерация письма для VIP-клиента
email = generate_email(
    {"name": "Алексей", "segment": "VIP",
     "last_purchase": "курс «Python Pro» (15 дней назад)",
     "interests": "AI, backend, DevOps"},
    {"name": "Скидка 30% на AI-курсы",
     "offer": "30% на любой AI-курс по промокоду VIP30",
     "tone": "тёплый персональный"}
)
print(email["subject"])
# "Алексей, вы готовы к AI? Специально для вас — 30% на курсы"

# AI A/B-тесты: генерация вариантов и анализ
pip install sendgrid scipy

from openai import OpenAI
from sendgrid import SendGridAPIClient, Mail
from scipy.stats import chi2_contingency
import random, json

oai = OpenAI()

# Шаг 1: AI генерирует 4 варианта subject line
resp = oai.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user",
        "content": "Сгенерируй 4 варианта темы письма для рассылки о скидке 20% на SaaS-продукт. Разные триггеры: срочность, выгода, любопытство, соцдоказательство. JSON-массив."}
])
subjects = json.loads(resp.choices[0].message.content)

# Шаг 2: Отправка со случайным выбором варианта
sg = SendGridAPIClient("YOUR_SENDGRID_KEY")
results = {i: {"sent": 0, "opened": 0} for i in range(4)}

for email_addr in subscriber_list:
    variant = random.randint(0, 3)
    message = Mail(
        from_email="hello@company.com",
        to_emails=email_addr,
        subject=subjects[variant],
        html_content="<h1>Специальное предложение</h1>..."
    )
    sg.send(message)
    results[variant]["sent"] += 1

# Шаг 3: Статистический анализ (после сбора данных)
# Симулируем: вариант 2 показал лучший open rate
results[2]["opened"] = 142  # 28.4%
results[0]["opened"] = 98   # 19.6%

contingency = [[r["opened"], r["sent"] - r["opened"]] for r in results.values()]
chi2, p_value, _, _ = chi2_contingency(contingency)
print(f"p-value: {p_value:.4f}")
# p-value: 0.023 — статистически значимо! Победил вариант 2

# Предиктивная модель: лучшее время отправки
pip install xgboost pandas

import pandas as pd
import xgboost as xgb
from sklearn.model_selection import train_test_split

# Загружаем историю рассылок
df = pd.read_csv("email_history.csv")
df["opened"] = df["status"].map({"open": 1, "sent": 0})

# Feature engineering
df["hour"] = pd.to_datetime(df["sent_at"]).dt.hour
df["dayofweek"] = pd.to_datetime(df["sent_at"]).dt.dayofweek
df["is_weekend"] = df["dayofweek"].isin([5, 6]).astype(int)

features = ["hour", "dayofweek", "is_weekend", "past_opens", "past_clicks"]
X_train, X_test, y_train, y_test = train_test_split(
    df[features], df["opened"], test_size=0.2
)

model = xgb.XGBClassifier(n_estimators=100, max_depth=5, learning_rate=0.1)
model.fit(X_train, y_train)
print(f"AUC: {model.score(X_test, y_test):.3f}")

# Предсказание лучшего часа для конкретного клиента
def best_send_time(customer_row):
    scores = {}
    for hour in range(8, 22):
        for day in range(7):
            row = customer_row.copy()
            row["hour"], row["dayofweek"] = hour, day
            row["is_weekend"] = 1 if day >= 5 else 0
            scores[(day, hour)] = model.predict_proba([row])[0][1]
    best = max(scores, key=scores.get)
    return best, scores[best]

best_time, prob = best_send_time(df.iloc[0][features])
print(f"Лучшее время: день {best_time[0]}, час {best_time[0]}:00 — вероятность {prob:.1%}")
# Лучшее время: день 3 (среда), час 10:00 — вероятность 34.2%

# Массовая отправка через SendGrid с персонализацией
pip install sendgrid

from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail, Personalization, Email

sg = SendGridAPIClient("YOUR_SENDGRID_API_KEY")

def send_bulk_campaign(campaign_name: str, recipients: list, ai_emails: dict):
    message = Mail(
        from_email=Email("noreply@company.com", "Команда Qantcore"),
        subject="{{subject}}"  # Substitution tag
    )
    message.template_id = "d-abc123def456"  # Dynamic template ID

    # Персонализация для каждого получателя
    for recipient in recipients:
        p = Personalization()
        p.add_to(Email(recipient["email"], recipient["name"]))
        p.add_dynamic_template_data({
            "subject": recipient["ai_subject"],
            "first_name": recipient["name"].split()[0],
            "body": recipient["ai_body"],
            "cta_url": recipient["tracked_url"],
            "unsubscribe_url": "https://company.com/unsub?id=" + recipient["id"]
        })
        # Кастомные поля для аналитики
        p.add_custom_arg({"campaign": campaign_name, "segment": recipient["segment"]})
        message.add_personalization(p)

    response = sg.send(message)
    return {"status": response.status_code, "body": response.body}

result = send_bulk_campaign("winter_sale_2026", recipients, ai_emails)
# Status: 202 Accepted — 500 писем отправлены за 1 запрос

# Авто-воронка на конечном автомате с AI-генерацией
import sqlite3, datetime
from enum import Enum

class Stage(Enum):
    WELCOME = "welcome"
    WARMUP_1 = "warmup_1"
    WARMUP_2 = "warmup_2"
    OFFER = "offer"
    REMINDER = "reminder"
    REACTIVATION = "reactivation"
    CONVERTED = "converted"

TRANSITIONS = {
    Stage.WELCOME:    {"any": Stage.WARMUP_1},
    Stage.WARMUP_1:   {"opened": Stage.WARMUP_2, "ignored": Stage.WARMUP_2},
    Stage.WARMUP_2:   {"clicked": Stage.OFFER, "ignored": Stage.OFFER},
    Stage.OFFER:      {"converted": Stage.CONVERTED, "ignored": Stage.REMINDER},
    Stage.REMINDER:   {"converted": Stage.CONVERTED, "any": Stage.REACTIVATION},
    Stage.REACTIVATION: {"any": Stage.CONVERTED},
}

def process_lead(lead_id: int, action: str):
    db = sqlite3.connect("funnel.db")
    cursor = db.execute("SELECT stage FROM leads WHERE id=?", (lead_id,))
    current = Stage(cursor.fetchone()[0])
    next_stage = TRANSITIONS[current].get(action) or TRANSITIONS[current].get("any")
    if next_stage:
        db.execute("UPDATE leads SET stage=?, updated_at=? WHERE id=?",
                   (next_stage.value, datetime.datetime.now(), lead_id))
        db.commit()
        return next_stage
    return current

# Шедулер: раз в час проверяет, кому пора отправлять письмо
def scheduler_tick():
    db = sqlite3.connect("funnel.db")
    leads = db.execute(
        """SELECT id, email, name, stage, segment
           FROM leads WHERE stage != 'converted'"""
    ).fetchall()
    for lead in leads:
        ai_email = generate_email(
            {"name": lead[2], "segment": lead[4]},
            {"name": f"stage_{lead[3]}", "offer": "..."}
        )
        send_single_email(lead[1], ai_email)
    # Воронка крутится автономно — AI генерирует каждое письмо