Ejemplo: Automatización de Hashtags con Python

import requests
import openai
from textblob import TextBlob
import pandas as pd
from datetime import datetime
import json

class HashtagOptimizer:
    """Sistema automatizado para optimización de hashtags usando IA"""
    
    def __init__(self, openai_key, instagram_token):
        openai.api_key = openai_key
        self.instagram_token = instagram_token
        self.trending_hashtags = []
        self.performance_data = {}
        
    def analyze_content_sentiment(self, caption):
        """Analiza el sentimiento del contenido para sugerir hashtags apropiados"""
        blob = TextBlob(caption)
        sentiment_score = blob.sentiment.polarity
        
        if sentiment_score > 0.3:
            sentiment_category = "positive"
        elif sentiment_score < -0.3:
            sentiment_category = "negative"  
        else:
            sentiment_category = "neutral"
            
        return {
            'sentiment': sentiment_category,
            'score': sentiment_score,
            'subjectivity': blob.sentiment.subjectivity
        }
    
    def get_trending_hashtags(self, niche, location="global"):
        """Obtiene hashtags trending usando APIs de redes sociales"""
        try:
            # Simulación de API call para obtener trending hashtags
            trending_api_url = f"https://api.trending-hashtags.com/v1/{niche}"
            response = requests.get(trending_api_url, params={
                'location': location,
                'timeframe': '24h'
            })
            
            if response.status_code == 200:
                trending_data = response.json()
                return trending_data.get('hashtags', [])
            
        except Exception as e:
            print(f"Error obteniendo trending hashtags: {e}")
            
        # Hashtags de fallback por categoría
        fallback_hashtags = {
            'fitness': ['#fitness', '#workout', '#gym', '#healthy', '#fitlife'],
            'food': ['#food', '#foodie', '#delicious', '#cooking', '#recipe'],
            'travel': ['#travel', '#explore', '#wanderlust', '#adventure', '#vacation'],
            'business': ['#business', '#entrepreneur', '#success', '#marketing', '#growth'],
            'tech': ['#technology', '#innovation', '#ai', '#digital', '#future']
        }
        
        return fallback_hashtags.get(niche, ['#content', '#social', '#media'])
    
    def generate_ai_hashtags(self, caption, image_description, target_audience):
        """Genera hashtags personalizados usando GPT"""
        try:
            prompt = f"""
            Actúa como un experto en marketing de redes sociales. Genera 30 hashtags optimizados para Instagram para el siguiente contenido:
            
            Caption: {caption}
            Descripción de imagen: {image_description}
            Audiencia objetivo: {target_audience}
            
            Incluye una mezcla de:
            - 5 hashtags muy populares (1M+ posts)
            - 10 hashtags medianamente populares (100K-1M posts)  
            - 10 hashtags de nicho (10K-100K posts)
            - 5 hashtags específicos/únicos (<10K posts)
            
            Formato: devuelve solo los hashtags separados por comas, sin numeración ni explicaciones.
            """
            
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "Eres un experto en hashtags de Instagram con acceso a datos actualizados."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=300,
                temperature=0.7
            )
            
            ai_hashtags = response.choices[0].message.content.strip()
            hashtags_list = [tag.strip() for tag in ai_hashtags.split(',')]
            
            return hashtags_list[:30]  # Máximo 30 hashtags
            
        except Exception as e:
            print(f"Error generando hashtags con IA: {e}")
            return []
    
    def analyze_hashtag_performance(self, hashtags_list):
        """Analiza el rendimiento histórico de hashtags"""
        performance_scores = {}
        
        for hashtag in hashtags_list:
            # Simulación de análisis de rendimiento
            try:
                # En implementación real, consultarías APIs de analytics
                estimated_reach = self.estimate_hashtag_reach(hashtag)
                competition_level = self.calculate_competition(hashtag)
                relevance_score = self.calculate_relevance(hashtag)
                
                performance_scores[hashtag] = {
                    'estimated_reach': estimated_reach,
                    'competition': competition_level,
                    'relevance': relevance_score,
                    'overall_score': (estimated_reach * relevance_score) / competition_level
                }
                
            except Exception as e:
                print(f"Error analizando {hashtag}: {e}")
                performance_scores[hashtag] = {'overall_score': 0.5}
        
        return performance_scores
    
    def estimate_hashtag_reach(self, hashtag):
        """Estima el alcance potencial de un hashtag"""
        # Simulación - en realidad usarías APIs de Instagram
        import random
        return random.uniform(0.1, 1.0)  # Score normalizado
    
    def calculate_competition(self, hashtag):
        """Calcula el nivel de competencia de un hashtag"""
        # Simulación basada en longitud y popularidad estimada
        if len(hashtag) < 10:
            return random.uniform(0.7, 1.0)  # Alta competencia
        else:
            return random.uniform(0.3, 0.7)  # Competencia media-baja
    
    def calculate_relevance(self, hashtag):
        """Calcula la relevancia del hashtag para el contenido"""
        # Simulación - en implementación real usarías NLP avanzado
        return random.uniform(0.4, 1.0)
    
    def optimize_hashtag_mix(self, all_hashtags, max_hashtags=30):
        """Optimiza la mezcla de hashtags para máximo alcance"""
        performance_data = self.analyze_hashtag_performance(all_hashtags)
        
        # Ordenar por score de rendimiento
        sorted_hashtags = sorted(
            performance_data.items(),
            key=lambda x: x[1]['overall_score'],
            reverse=True
        )
        
        # Seleccionar los mejores hashtags con diversidad
        optimized_mix = []
        high_competition = []
        medium_competition = []
        low_competition = []
        
        for hashtag, data in sorted_hashtags:
            if data['competition'] > 0.7:
                high_competition.append(hashtag)
            elif data['competition'] > 0.4:
                medium_competition.append(hashtag)
            else:
                low_competition.append(hashtag)
        
        # Mezcla estratégica: 30% alta competencia, 50% media, 20% baja
        optimized_mix.extend(high_competition[:int(max_hashtags * 0.3)])
        optimized_mix.extend(medium_competition[:int(max_hashtags * 0.5)])
        optimized_mix.extend(low_competition[:int(max_hashtags * 0.2)])
        
        return optimized_mix[:max_hashtags]
    
    def generate_complete_hashtag_strategy(self, caption, image_description, 
                                         target_audience, niche, location="global"):
        """Pipeline completo de optimización de hashtags"""
        
        print("🔍 Iniciando optimización de hashtags...")
        
        # 1. Análisis de sentimiento
        sentiment_data = self.analyze_content_sentiment(caption)
        print(f"📊 Sentimiento del contenido: {sentiment_data['sentiment']}")
        
        # 2. Obtener hashtags trending
        trending = self.get_trending_hashtags(niche, location)
        print(f"📈 Hashtags trending obtenidos: {len(trending)}")
        
        # 3. Generar hashtags con IA
        ai_hashtags = self.generate_ai_hashtags(caption, image_description, target_audience)
        print(f"🤖 Hashtags generados por IA: {len(ai_hashtags)}")
        
        # 4. Combinar todas las fuentes
        all_hashtags = list(set(trending + ai_hashtags))  # Eliminar duplicados
        
        # 5. Optimizar mezcla final
        final_hashtags = self.optimize_hashtag_mix(all_hashtags)
        
        # 6. Generar reporte
        report = {
            'timestamp': datetime.now().isoformat(),
            'content_sentiment': sentiment_data,
            'recommended_hashtags': final_hashtags,
            'hashtag_count': len(final_hashtags),
            'sources': {
                'trending': len(trending),
                'ai_generated': len(ai_hashtags),
                'total_analyzed': len(all_hashtags)
            },
            'optimization_strategy': 'Mezcla equilibrada para máximo alcance'
        }
        
        return report
    
    def format_for_instagram(self, hashtags_list):
        """Formatea los hashtags para copiar-pegar en Instagram"""
        formatted = ' '.join([f'#{tag.lstrip("#")}' for tag in hashtags_list])
        return formatted
    
    def save_performance_data(self, report, filename="hashtag_optimization_report.json"):
        """Guarda el reporte de optimización"""
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        print(f"📄 Reporte guardado en: {filename}")

# Ejemplo de uso
def main():
    # Configuración (en producción, usar variables de entorno)
    OPENAI_API_KEY = "tu_openai_api_key"
    INSTAGRAM_TOKEN = "tu_instagram_token"
    
    # Inicializar optimizador
    optimizer = HashtagOptimizer(OPENAI_API_KEY, INSTAGRAM_TOKEN)
    
    # Datos del post a optimizar
    caption = "Descubre los 5 secretos para aumentar tu productividad que los emprendedores exitosos no quieren que sepas. ¿Estás listo para transformar tu rutina diaria?"
    image_description = "Infografía moderna con 5 iconos representando consejos de productividad, colores azul y blanco, diseño minimalista"
    target_audience = "Emprendedores y profesionales de 25-40 años interesados en crecimiento personal"
    niche = "business"
    location = "spain"
    
    # Generar estrategia completa
    strategy = optimizer.generate_complete_hashtag_strategy(
        caption, image_description, target_audience, niche, location
    )
    
    # Mostrar resultados
    print("\n" + "="*50)
    print("📱 ESTRATEGIA DE HASHTAGS OPTIMIZADA")
    print("="*50)
    print(f"Hashtags recomendados: {strategy['hashtag_count']}")
    print(f"Sentimiento: {strategy['content_sentiment']['sentiment']}")
    print("\n📋 HASHTAGS PARA COPIAR:")
    print(optimizer.format_for_instagram(strategy['recommended_hashtags']))
    
    # Guardar reporte
    optimizer.save_performance_data(strategy)
    
    return strategy

if __name__ == "__main__":
    # Ejecutar optimización de hashtags
    resultado = main()