SEO Organic Ranking Optimization — 电商 SEO 自然排名元数据优化

from dataclasses import dataclass, field
from typing import List, Dict
import re

@dataclass
class ListingMetadata:
    asin: str
    title: str
    bullets: List[str]
    backend_keywords: str
    category: str

@dataclass
class RankingSignal:
    keyword: str
    current_rank: int
    click_rate: float
    weekly_change: int

def extract_keywords_from_listing(listing: ListingMetadata) -> Dict[str, int]:
    text = (listing.title + " " + " ".join(listing.bullets) + " " + listing.backend_keywords).lower()
    words = re.findall(r'\b[a-z]{3,}\b', text)
    stopwords = {'the','and','for','with','our','your','this','that','are','has'}
    freq = {}
    for w in words:
        if w not in stopwords:
            freq[w] = freq.get(w, 0) + 1
    return dict(sorted(freq.items(), key=lambda x: -x[1])[:30])

def gap_analysis(my_listing: ListingMetadata, competitor_listings: List[ListingMetadata],
                  target_keywords: List[str]) -> Dict:
    my_kws = extract_keywords_from_listing(my_listing)
    comp_kw_freq = {}
    for comp in competitor_listings:
        for kw, cnt in extract_keywords_from_listing(comp).items():
            comp_kw_freq[kw] = comp_kw_freq.get(kw, 0) + cnt
    comp_top = sorted(comp_kw_freq.items(), key=lambda x: -x[1])[:20]
    missing_from_title = [kw for kw in target_keywords if kw not in my_listing.title.lower()]
    gaps = [kw for kw, _ in comp_top if kw not in my_kws or my_kws.get(kw, 0) < 1]
    return {"my_top_keywords": list(my_kws.keys())[:10],
            "competitor_top_keywords": [k for k,_ in comp_top[:10]],
            "keywords_missing_from_title": missing_from_title,
            "gap_keywords": gaps[:8],
            "coverage_score": round(len([k for k in target_keywords if k in my_kws]) / len(target_keywords) * 100, 1)}

def generate_optimized_title(original: str, must_include: List[str], max_len: int = 200) -> str:
    base = original
    for kw in must_include:
        if kw.lower() not in base.lower() and len(base) + len(kw) + 2 < max_len:
            base = base + " - " + kw.title()
    return base[:max_len]

def compute_ranking_score(listing: ListingMetadata, signals: List[RankingSignal]) -> Dict:
    kws = extract_keywords_from_listing(listing)
    title_kw_density = sum(1 for kw in kws if kw in listing.title.lower()) / max(len(kws), 1)
    avg_rank = sum(s.current_rank for s in signals) / max(len(signals), 1)
    improving = sum(1 for s in signals if s.weekly_change < 0) / max(len(signals), 1)
    score = round(title_kw_density * 40 + (1 - avg_rank/100) * 40 + improving * 20, 1)
    return {"seo_score": score, "title_kw_density": round(title_kw_density, 2),
            "avg_rank": round(avg_rank, 1), "improving_keywords_pct": round(improving * 100)}