Articles
Aucun article disponible.
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import requests
from bs4 import BeautifulSoup
import json
import matplotlib.pyplot as plt
from scipy import stats
class AliExpressTrendDetector:
def __init__(self, affiliate_id):
self.affiliate_id = affiliate_id
self.headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}
self.trends_data = {}
def track_category(self, category_url, days=30):
"""Suit l'évolution d'une catégorie sur une période donnée"""
daily_data = []
for day in range(days):
date = datetime.now() - timedelta(days=day)
products = self._scrape_category(category_url)
daily_stats = {
'date': date,
'avg_price': np.mean([p['price'] for p in products]),
'total_sales': sum([p['sales'] for p in products]),
'new_products': len([p for p in products if p['is_new']]),
'products': products
}
daily_data.append(daily_stats)
self.trends_data[category_url] = daily_data
return daily_data
def detect_trends(self, min_growth_rate=0.1):
"""Détecte les tendances significatives"""
trends = {
'rising_products': [],
'trending_categories': [],
'price_trends': [],
'seasonal_patterns': [],
'emerging_keywords': []
}
for category_url, data in self.trends_data.items():
# Analyse des produits en hausse
products_data = pd.DataFrame([p for d in data for p in d['products']])
rising_products = self._detect_rising_products(products_data, min_growth_rate)
trends['rising_products'].extend(rising_products)
# Analyse des catégories
category_data = pd.DataFrame(data)
if self._is_trending_category(category_data):
trends['trending_categories'].append(category_url)
# Analyse des prix
price_trend = self._analyze_price_trends(category_data)
trends['price_trends'].append(price_trend)
# Analyse saisonnière
seasonal = self._detect_seasonal_patterns(category_data)
if seasonal:
trends['seasonal_patterns'].append(seasonal)
# Analyse des mots-clés émergents
keywords = self._extract_emerging_keywords(products_data)
trends['emerging_keywords'].extend(keywords)
return trends
def generate_trend_report(self, trends):
"""Génère un rapport détaillé des tendances"""
report = {
'timestamp': datetime.now().isoformat(),
'summary': {
'total_rising_products': len(trends['rising_products']),
'trending_categories': len(trends['trending_categories']),
'emerging_keywords': len(trends['emerging_keywords'])
},
'detailed_trends': trends,
'recommendations': self._generate_recommendations(trends)
}
return report
def visualize_trends(self, trends):
"""Crée des visualisations des tendances détectées"""
plt.figure(figsize=(15, 10))
# Graphique des produits en hausse
plt.subplot(2, 2, 1)
rising_products = pd.DataFrame(trends['rising_products'])
plt.bar(rising_products['title'][:5], rising_products['growth_rate'][:5])
plt.title('Top 5 des produits en hausse')
plt.xticks(rotation=45)
# Graphique des prix
plt.subplot(2, 2, 2)
price_trends = pd.DataFrame(trends['price_trends'])
plt.plot(price_trends['date'], price_trends['avg_price'])
plt.title('Évolution des prix')
plt.tight_layout()
return plt
def _scrape_category(self, category_url):
"""Extrait les données d'une catégorie"""
products = []
try:
response = requests.get(category_url, headers=self.headers)
soup = BeautifulSoup(response.content, 'html.parser')
for product in soup.find_all('div', class_='product-card'):
products.append({
'title': product.find('h1').text.strip(),
'price': float(product.find('span', class_='price').text.strip()),
'sales': int(product.find('span', class_='sales').text.strip()),
'rating': float(product.find('span', class_='rating').text.strip()),
'is_new': 'new' in product.get('class', []),
'url': product.find('a')['href']
})
except Exception as e:
print(f"Erreur lors de l'extraction: {str(e)}")
return products
def _detect_rising_products(self, products_df, min_growth_rate):
"""Identifie les produits en forte croissance"""
products_df['growth_rate'] = products_df.groupby('title')['sales'].pct_change()
rising = products_df[products_df['growth_rate'] > min_growth_rate]
return rising.to_dict('records')
def _is_trending_category(self, category_data):
"""Détermine si une catégorie est en tendance"""
sales_trend = stats.linregress(range(len(category_data)), category_data['total_sales'])
return sales_trend.slope > 0 and sales_trend.pvalue < 0.05
def _analyze_price_trends(self, category_data):
"""Analyse l'évolution des prix"""
return {
'date': category_data['date'],
'avg_price': category_data['avg_price'],
'trend': 'increasing' if category_data['avg_price'].is_monotonic_increasing else 'decreasing'
}
def _detect_seasonal_patterns(self, category_data):
"""Détecte les motifs saisonniers"""
if len(category_data) >= 30: # Besoin d'au moins 30 jours de données
sales = category_data['total_sales']
autocorr = np.correlate(sales, sales, mode='full')
return {
'has_seasonal_pattern': bool(np.any(autocorr[len(sales):] > 0.7)),
'pattern_length': np.argmax(autocorr[len(sales):]) if np.any(autocorr[len(sales):] > 0.7) else None
}
return None
def _extract_emerging_keywords(self, products_df):
"""Identifie les mots-clés émergents"""
from collections import Counter
import re
# Extraction des mots des titres
words = ' '.join(products_df['title']).lower()
words = re.findall(r'\w+', words)
# Comptage des occurrences
word_counts = Counter(words)
# Identification des mots fréquents (seuil arbitraire)
emerging = [word for word, count in word_counts.items() if count > len(products_df) * 0.1]
return emerging
def _generate_recommendations(self, trends):
"""Génère des recommandations basées sur les tendances"""
recommendations = []
# Recommandations basées sur les produits en hausse
if trends['rising_products']:
recommendations.append({
'type': 'product_opportunity',
'message': f"Focalisez-vous sur les {len(trends['rising_products'])} produits en forte croissance",
'products': [p['title'] for p in trends['rising_products'][:5]]
})
# Recommandations basées sur les catégories
if trends['trending_categories']:
recommendations.append({
'type': 'category_focus',
'message': "Concentrez vos efforts sur ces catégories en tendance",
'categories': trends['trending_categories']
})
# Recommandations basées sur les mots-clés
if trends['emerging_keywords']:
recommendations.append({
'type': 'keyword_optimization',
'message': "Utilisez ces mots-clés émergents dans votre contenu",
'keywords': trends['emerging_keywords'][:10]
})
return recommendations