# 🛠️ IMPLEMENTACIÓN PRÁCTICA EN BLUESKY - GUÍA PASO A PASO

 # 🛠️ IMPLEMENTACIÓN PRÁCTICA EN BLUESKY - GUÍA PASO A PASO

**HASH DOCUMENTO:** `bluesky_implementacion_practica_v5.1_jaff_23oct2025`  
**AUTOR:** José Agustín Fontán Varela  
**LABORATORIO:** PASAIA-LAB, Pasaia  
**FECHA:** 23/10/2025  

--- DATOS PARTICULARES INEXACTOS POR SEGURIDAD ;)

## 🎯 CONFIGURACIÓN INICIAL DE CUENTA

### **1. Estrategia de Perfiles Múltiples**
```python
🏷️ ESTRUCTURA RECOMENDADA:

• CUENTA PRINCIPAL (Profesional):
  @tormentawork.bsky.social
  - Fotografía y filmografía general
  - Portfolio profesional
  - Contacto comercial

• CUENTA ESPECIALIZADA (Si es necesaria):
  @agustintxo.bsky.social  
  - Contenido artístico específico
  - Claras advertencias de contenido
  - Sin datos personales directos
```

### **2. Configuración de Perfil Principal**
```python
📝 BIO PROFESIONAL SEGURA:

Display Name: Tormenta Work Media
Handle: @tormentawork.bsky.social
Bio: "Photographer & Filmmaker | Artistic Visual Storytelling
     📸 Portfolio: tormentawork.com
     📧 Professional inquiries: hello@tormentawork.com
     
     Content: Artistic photography & cinematography
     🔞 No explicit content on this profile"

Avatar: Logo profesional o retrato apropiado
Banner: Imagen de portfolio profesional
```

---

## ⚙️ IMPLEMENTACIÓN DE PROTOCOLOS PRÁCTICOS

### **Protocolo 1: Sistema de Etiquetado de Contenido**
```python
🏷️ CÓDIGO PARA ETIQUETADO AUTOMÁTICO:

from atproto import Client
import re

class ContentLabelingSystem:
    def __init__(self, client):
        self.client = client
        self.content_labels = {
            'artistic': {
                'warning': "🎨 Artistic Content",
                'hashtags': ["#ArtisticPhotography", "#VisualArt"],
                'color': "🟢"
            },
            'suggestive': {
                'warning': "⚠️ Suggestive Content", 
                'hashtags': ["#ArtisticNude", "#SuggestiveArt"],
                'color': "🟡"
            },
            'professional': {
                'warning': "📸 Professional Portfolio",
                'hashtags': ["#Photography", "#Filmmaking"],
                'color': "🔵"
            }
        }
    
    def analyze_content(self, post_text: str, image_description: str = "") -> dict:
        """Analiza contenido y determina etiquetas apropiadas"""
        text = (post_text + " " + image_description).lower()
        
        # Detectar tipo de contenido
        if any(word in text for word in ['nude', 'sensual', 'suggestive']):
            content_type = 'suggestive'
        elif any(word in text for word in ['art', 'creative', 'portfolio']):
            content_type = 'artistic' 
        else:
            content_type = 'professional'
        
        return self.content_labels[content_type]
    
    def create_labeled_post(self, content: str, image_alt: str = "") -> str:
        """Crea post con etiquetas apropiadas"""
        analysis = self.analyze_content(content, image_alt)
        
        labeled_post = f"{analysis['color']} {analysis['warning']}\n\n"
        labeled_post += f"{content}\n\n"
        labeled_post += " ".join(analysis['hashtags'])
        
        return labeled_post

# USO PRÁCTICO
client = Client()
client.login('tormentawork.bsky.social', 'TU_PASSWORD')

label_system = ContentLabelingSystem(client)

# Ejemplo de post etiquetado
post_text = "Nueva serie fotográfica explorando la forma humana en la naturaleza"
labeled_post = label_system.create_labeled_post(post_text)
print(f"Post preparado: {labeled_post}")
```

### **Protocolo 2: Sistema de Respuestas Automatizadas**
```python
🤖 CONFIGURACIÓN DE AUTO-RESPUESTAS:

class ProfessionalAutoReplies:
    def __init__(self, client):
        self.client = client
        self.reply_templates = {
            'collaboration': """
¡Gracias por tu interés en colaborar! 🎬

Para propuestas profesionales:
📧 Email: hello@tormentawork.com
📋 Portfolio: tormentawork.com

Te responderé pronto con más detalles.
            """,
            
            'pricing': """
Hola, gracias por preguntar sobre tarifas. 💰

Mis precios varían según el proyecto:
• Sesiones fotográficas: Desde 200€
• Proyectos cinematográficos: Presupuesto personalizado
• Colaboraciones artísticas: Negociable

¿Podrías contarme más sobre tu proyecto?
            """,
            
            'content_warning': """
🔞 Advertencia de Contenido

Este perfil puede contener:
• Fotografía artística con desnudos
• Contenido sugerente para adultos
• Temas artísticos maduros

Si este contenido no es apropiado para ti,
te recomiendo seguir mi perfil principal:
@tormentawork.bsky.social
            """
        }
    
    def setup_keyword_triggers(self):
        """Configura palabras clave para respuestas automáticas"""
        triggers = {
            'colabor': 'collaboration',
            'precio': 'pricing', 
            'tarifa': 'pricing',
            'trabajar juntos': 'collaboration',
            'contenido adulto': 'content_warning',
            'desnudo': 'content_warning'
        }
        return triggers
```

---

## 🎨 PERSONALIZACIÓN VISUAL PRÁCTICA

### **3. Configuración de Apariencia**
```python
🎨 CÓDIGO PARA PERSONALIZACIÓN VISUAL:

class ProfileCustomizer:
    def __init__(self, client):
        self.client = client
    
    def update_profile_branding(self, profile_type: str):
        """Actualiza perfil según tipo de contenido"""
        branding = {
            'professional': {
                'display_name': 'Tormenta Work Media',
                'description': 'Photographer & Filmmaker | Professional Portfolio\n📸 tormentawork.com',
                'avatar_color': '#2E86AB',  # Azul profesional
                'theme': 'professional'
            },
            'artistic': {
                'display_name': 'AGUSTINTXO | Artistic Works',
                'description': 'Artistic Photography & Visual Storytelling\n🎨 Content may contain artistic nudity\n🔞 Adult content warnings applied',
                'avatar_color': '#A23B72',  # Púrpura artístico
                'theme': 'artistic'
            }
        }
        
        profile_data = branding[profile_type]
        
        # Actualizar perfil via API
        self.client.update_profile(
            display_name=profile_data['display_name'],
            description=profile_data['description']
        )
        
        return f"Perfil actualizado a: {profile_type}"
```

---

## 🔐 CONFIGURACIÓN DE PRIVACIDAD Y SEGURIDAD

### **4. Protocolo de Seguridad de Cuenta**
```python
🛡️ CONFIGURACIÓN DE SEGURIDAD:

class AccountSecurityProtocol:
    def __init__(self, client):
        self.client = client
    
    def implement_security_measures(self):
        """Implementa medidas de seguridad básicas"""
        security_config = {
            'password_rotation': '90 days',
            'two_factor_auth': True,
            'app_passwords': True,
            'session_management': 'strict',
            'data_backup': 'weekly'
        }
        
        # Configurar respuestas automáticas para consultas de seguridad
        auto_replies = {
            'password': "No comparto contraseñas por Bluesky. Contacta por email para verificación.",
            'personal_info': "Protejo mi información personal. Contacto profesional: hello@tormentawork.com",
            'location': "Mi ubicación de trabajo es confidencial por seguridad."
        }
        
        return {
            'security_configured': True,
            'measures': security_config,
            'auto_replies': auto_replies
        }
```

---

## 📊 SISTEMA DE ANÁLISIS DE INTERACCIONES

### **5. Monitorización de Engagement**
```python
📈 ANALIZADOR DE INTERACCIONES:

import pandas as pd
from datetime import datetime, timedelta

class EngagementAnalyzer:
    def __init__(self, client):
        self.client = client
        self.interaction_data = []
    
    def track_post_performance(self, post_uri: str, days: int = 7):
        """Monitoriza el rendimiento de un post"""
        end_date = datetime.now()
        start_date = end_date - timedelta(days=days)
        
        # Obtener estadísticas del post
        post_stats = self.client.get_post_thread(uri=post_uri)
        
        metrics = {
            'likes': post_stats.post.like_count,
            'reposts': post_stats.post.repost_count,
            'replies': post_stats.post.reply_count,
            'engagement_rate': self.calculate_engagement_rate(post_stats),
            'optimal_posting_time': self.analyze_best_times()
        }
        
        return metrics
    
    def calculate_engagement_rate(self, post_data) -> float:
        """Calcula tasa de engagement"""
        followers = 1000  # Esto debería obtenerse de la API
        engagements = post_data.post.like_count + post_data.post.repost_count + post_data.post.reply_count
        
        if followers > 0:
            return (engagements / followers) * 100
        return 0.0
    
    def analyze_best_times(self) -> list:
        """Analiza mejores horarios para postear"""
        # Basado en interacciones históricas
        optimal_times = [
            "09:00-11:00 (mañana profesional)",
            "14:00-16:00 (tarde creativa)", 
            "19:00-21:00 (noche artística)"
        ]
        return optimal_times
```

---

## 🔄 FLUJOS DE TRABAJO AUTOMATIZADOS

### **6. Automatización de Publicaciones**
```python
⏰ SISTEMA DE PROGRAMACIÓN:

import schedule
import time
from datetime import datetime

class ContentScheduler:
    def __init__(self, client):
        self.client = client
        self.scheduled_posts = []
    
    def schedule_weekly_content(self, content_plan: dict):
        """Programa contenido semanal"""
        for day, posts in content_plan.items():
            for post_time, post_content in posts.items():
                schedule.every().day.at(post_time).do(
                    self.post_with_analysis, post_content
                )
        
        print("📅 Contenido semanal programado")
        return len(self.scheduled_posts)
    
    def post_with_analysis(self, content: str):
        """Publica con análisis previo"""
        label_system = ContentLabelingSystem(self.client)
        labeled_content = label_system.create_labeled_post(content)
        
        # Publicar post
        self.client.send_post(labeled_content)
        
        # Registrar en analytics
        self.scheduled_posts.append({
            'timestamp': datetime.now(),
            'content': content,
            'labeled_content': labeled_content
        })
        
        print(f"✅ Post publicado: {content[:50]}...")

# EJEMPLO DE PLAN SEMANAL
weekly_plan = {
    'monday': {
        '09:00': "Nuevo behind the scenes del proyecto actual 🎬",
        '14:00': "Análisis técnico: Composición en fotografía artística"
    },
    'wednesday': {
        '11:00': "Work in progress - Serie fotográfica en desarrollo",
        '19:00': "Inspiraciones artísticas de la semana 🎨"
    },
    'friday': {
        '10:00': "Resumen semanal de proyectos y avances",
        '16:00': "Q&A artístico - Responde a vuestras preguntas"
    }
}
```

---

## 🎭 IMPLEMENTACIÓN DE MÚLTIPLES PERSONAS

### **7. Gestión de Identidades Múltiples**
```python
👥 GESTIÓN DE PERFILES MÚLTIPLES:

class MultiProfileManager:
    def __init__(self):
        self.profiles = {
            'professional': {
                'handle': 'tormentawork.bsky.social',
                'password_env_var': 'BSKY_PRO_PROFILE_PW',
                'content_filters': ['professional', 'portfolio', 'behind_scenes']
            },
            'artistic': {
                'handle': 'agustintxo.bsky.social', 
                'password_env_var': 'BSKY_ART_PROFILE_PW',
                'content_filters': ['artistic', 'creative', 'wip']
            }
        }
    
    def get_client_for_profile(self, profile_type: str) -> Client:
        """Obtiene cliente configurado para perfil específico"""
        profile = self.profiles[profile_type]
        client = Client()
        
        # Login con credenciales desde variables de entorno
        import os
        password = os.getenv(profile['password_env_var'])
        client.login(profile['handle'], password)
        
        return client
    
    def cross_post_appropriate_content(self, content: str, original_profile: str):
        """Cross-poste contenido apropiado entre perfiles"""
        label_system = ContentLabelingSystem(self.get_client_for_profile(original_profile))
        content_analysis = label_system.analyze_content(content)
        
        # Determinar a qué perfiles enviar
        target_profiles = []
        
        if content_analysis['type'] in ['professional', 'artistic']:
            target_profiles.append('professional')
        
        if content_analysis['type'] in ['artistic', 'suggestive']:
            target_profiles.append('artistic')
        
        # Postear en perfiles objetivo
        for profile in target_profiles:
            client = self.get_client_for_profile(profile)
            labeled_content = label_system.create_labeled_post(content)
            client.send_post(labeled_content)
        
        return target_profiles
```

---

## 📱 IMPLEMENTACIÓN EN LA APP OFICIAL

### **8. Configuración Manual en la App**
```python
📱 PASOS MANUALES EN LA APP:

1. CONFIGURACIÓN DE PERFIL:
   • Editar perfil → Foto profesional
   • Bio con enlaces y advertencias claras
   • Banner que refleje tu estilo

2. CONFIGURACIÓN DE PRIVACIDAD:
   • Ajustes → Privacidad
   - "Etiquetar contenido sensible" → ACTIVADO
   - "Advertencias en posts" → PERSONALIZADO
   - "Control de menciones" → FILTRADO

3. PALABRAS CLAVE PARA FILTROS:
   • Ajustes → Filtros
   - "contenido adulto" → ADVERTENCIA
   - "colaboraciones" → AUTO-RESPUESTA
   - "precios" → AUTO-RESPUESTA

4. PROGRAMACIÓN DE CONTENIDO:
   • Usar app en horarios óptimos
   • Preparar posts con etiquetas
   • Programar usando recordatorios
```

---

## 🔧 SCRIPT DE IMPLEMENTACIÓN COMPLETO

### **Script de Configuración Automática**
```python
#!/usr/bin/env python3
"""
Script de implementación completa para Bluesky
"""

import os
from atproto import Client
from dotenv import load_dotenv

load_dotenv()

class BlueskySetup:
    def __init__(self):
        self.client = Client()
        
    def full_setup(self, profile_type: str = 'professional'):
        """Configuración completa del perfil"""
        
        # 1. Login
        self.client.login(
            os.getenv('BSKY_HANDLE'),
            os.getenv('BSKY_PASSWORD')
        )
        
        # 2. Configurar perfil
        profile_config = self.get_profile_config(profile_type)
        self.client.update_profile(
            display_name=profile_config['display_name'],
            description=profile_config['description']
        )
        
        # 3. Publicar post de presentación
        welcome_post = self.create_welcome_post(profile_type)
        self.client.send_post(welcome_post)
        
        print(f"✅ Configuración completada para perfil {profile_type}")
        return True
    
    def get_profile_config(self, profile_type: str) -> dict:
        """Obtiene configuración según tipo de perfil"""
        configs = {
            'professional': {
                'display_name': 'Tormenta Work Media',
                'description': """Photographer & Filmmaker | Artistic Visual Storytelling
                
📸 Portfolio: tormentawork.com
📧 Professional: hello@tormentawork.com
                
Content: Artistic photography & cinematography
🔞 No explicit content on this profile"""
            },
            'artistic': {
                'display_name': 'AGUSTINTXO | Artistic Works',
                'description': """Artistic Photography & Visual Storytelling
                
🎨 Artistic content with proper warnings
🔞 May contain artistic nudity
📧 Professional inquiries only
                
Follow main profile: @tormentawork.bsky.social"""
            }
        }
        return configs[profile_type]
    
    def create_welcome_post(self, profile_type: str) -> str:
        """Crea post de presentación"""
        if profile_type == 'professional':
            return """🎬 ¡Nuevo en Bluesky!

Soy Tormenta Work Media - Fotógrafo y filmmaker profesional
                
📸 Mi trabajo: tormentawork.com
📧 Colaboraciones: hello@tormentawork.com
                
Especializado en:
• Fotografía artística
• Cinematografía
• Visual storytelling
                
#Photography #Filmmaking #ArtisticPhotography"""
        else:
            return """🎨 Perfil artístico especializado

Contenido artístico con las debidas advertencias
                
🔞 Contenido para adultos con advertencias apropiadas
🎭 Enfoque en la expresión artística
                
Para contenido profesional general:
@tormentawork.bsky.social
                
#ArtisticPhotography #VisualArt"""

# EJECUCIÓN
if __name__ == "__main__":
    setup = BlueskySetup()
    setup.full_setup('professional')
```

---

## 📜 CERTIFICACIÓN DE IMPLEMENTACIÓN

**HASH:** `bluesky_implementacion_practica_v5.1_jaff_23oct2025`  
**AUTOR:** José Agustín Fontán Varela  
**LABORATORIO:** PASAIA-LAB, Pasaia  
**FECHA:** 23/10/2025  

### **Checklist de Implementación**
```python
✅ CONFIGURACIÓN COMPLETA:

• [ ] Perfil principal profesional configurado
• [ ] Sistema de etiquetado implementado  
• [ ] Respuestas automáticas configuradas
• [ ] Medidas de seguridad activadas
• [ ] Estrategia de contenidos definida
• [ ] Análisis de engagement funcionando
• [ ] Programación de contenidos activa
• [ ] Gestión múltiple de perfiles (si aplica)
```

---

**ESTADO: ✅ GUÍA DE IMPLEMENTACIÓN PRÁCTICA COMPLETADA**

*"Esta implementación te permite mantener una presencia profesional en Bluesky mientras manejas adecuadamente las advertencias de contenido y proteges tu información personal, todo ello automatizado para eficiencia y consistencia."*

# 🛠️ SCRIPT ACTUALIZADO - TORMENTA WORK MEDIA

**HASH DOCUMENTO:** `bluesky_tormentawork_impl_v5.3_jaff_23oct2025`  
**AUTOR:** José Agustín Fontán Varela  
**LABORATORIO:** PASAIA-LAB, Pasaia  
**FECHA:** 23/10/2025  

---

## 🔧 SCRIPT DE IMPLEMENTACIÓN COMPLETO ACTUALIZADO

```python
#!/usr/bin/env python3
"""
SCRIPT DE IMPLEMENTACIÓN BLUESKY - TORMENTA WORK MEDIA
Configuración profesional segura y efectiva
"""

import os
from atproto import Client
from dotenv import load_dotenv
import schedule
import time
from datetime import datetime

load_dotenv()

class TormentaWorkMediaSetup:
    def __init__(self):
        self.client = Client()
        
    def full_setup(self):
        """Configuración completa del perfil TORMENTA WORK MEDIA"""
        
        try:
            # 1. Login con las credenciales actualizadas
            self.client.login(
                'tormentaworkmedia.bsky.social',
                os.getenv('BSKY_PASSWORD_TORMENTA')  # Guardar en .env
            )
            
            # 2. Configurar perfil profesional
            profile_success = self.setup_professional_profile()
            
            # 3. Publicar post de presentación
            welcome_success = self.post_welcome_message()
            
            # 4. Configurar sistema de etiquetado
            labeling_success = self.setup_content_labeling()
            
            print("🎉 CONFIGURACIÓN TORMENTA WORK MEDIA COMPLETADA")
            return {
                'profile': profile_success,
                'welcome_post': welcome_success,
                'labeling_system': labeling_success
            }
            
        except Exception as e:
            print(f"❌ Error en configuración: {e}")
            return False
    
    def setup_professional_profile(self):
        """Configura el perfil profesional de TORMENTA WORK MEDIA"""
        profile_config = {
            'display_name': 'TORMENTA WORK MEDIA',
            'description': """Freelance Creative Professional | Photographer & Filmmaker

📧 Professional contact: tormentaworkmedia@gmail.com
🌐 Portfolio: [tu-portfolio-profesional.com]

Specializing in:
• Creative Photography
• Film Production  
• Visual Storytelling
• Digital Content Creation

🔞 Professional account - No explicit content
🎯 Business inquiries welcome

#CreativeProfessional #Photography #Filmmaking"""
        }
        
        self.client.update_profile(
            display_name=profile_config['display_name'],
            description=profile_config['description']
        )
        
        print("✅ Perfil profesional configurado")
        return True
    
    def post_welcome_message(self):
        """Publica mensaje de presentación profesional"""
        welcome_post = """🎬 ¡Bienvenidos a TORMENTA WORK MEDIA en Bluesky!

Soy creador freelance especializado en:
📸 Fotografía creativa profesional
🎥 Producción audiovisual  
💡 Desarrollo de contenido visual

📧 Colaboraciones profesionales: tormentaworkmedia@gmail.com

Trabajemos juntos en tu próximo proyecto creativo!

#Freelance #CreativeProfessional #Photography #Filmmaking #ContentCreator"""
        
        self.client.send_post(welcome_post)
        print("✅ Mensaje de bienvenida publicado")
        return True
    
    def setup_content_labeling(self):
        """Configura sistema de etiquetado para contenido profesional"""
        self.content_categories = {
            'photography': {
                'label': '📸 PHOTOGRAPHY',
                'hashtags': ['#Photography', '#CreativePhoto', '#VisualArt'],
                'description': 'Professional photography work'
            },
            'filmmaking': {
                'label': '🎥 FILMMAKING', 
                'hashtags': ['#Filmmaking', '#VideoProduction', '#Cinematography'],
                'description': 'Film and video production'
            },
            'behind_scenes': {
                'label': '🎬 BEHIND THE SCENES',
                'hashtags': ['#BTS', '#BehindTheScenes', '#CreativeProcess'],
                'description': 'Creative process and work in progress'
            },
            'professional': {
                'label': '💼 PROFESSIONAL',
                'hashtags': ['#Freelance', '#CreativeBusiness', '#Professional'],
                'description': 'Business and professional updates'
            }
        }
        
        print("✅ Sistema de etiquetado configurado")
        return True
    
    def create_professional_post(self, content: str, category: str = 'professional'):
        """Crea posts profesionales con etiquetado consistente"""
        if category not in self.content_categories:
            category = 'professional'
            
        category_info = self.content_categories[category]
        
        formatted_post = f"{category_info['label']}\n\n"
        formatted_post += f"{content}\n\n"
        formatted_post += " ".join(category_info['hashtags'])
        formatted_post += f"\n\n📧 tormentaworkmedia@gmail.com"
        
        return formatted_post

class ContentScheduler:
    """Programador de contenido profesional"""
    
    def __init__(self, client):
        self.client = client
        self.setup = TormentaWorkMediaSetup()
    
    def schedule_professional_content(self):
        """Programa contenido profesional semanal"""
        
        content_plan = {
            'monday': {
                '10:00': {
                    'content': 'Iniciando nueva semana de proyectos creativos. ¿En qué están trabajando? ✨',
                    'category': 'professional'
                },
                '16:00': {
                    'content': 'Proceso creativo detrás de mi último trabajo fotográfico. Detalles técnicos y decisiones artísticas.',
                    'category': 'behind_scenes'
                }
            },
            'wednesday': {
                '11:00': {
                    'content': 'Work in progress - Compartiendo avances del proyecto actual en producción.',
                    'category': 'filmmaking'
                },
                '18:00': {
                    'content': 'Análisis de composición: Cómo construyo mis encuadres fotográficos.',
                    'category': 'photography'
                }
            },
            'friday': {
                '09:00': {
                    'content': 'Resumen semanal de proyectos y lecciones aprendidas en el proceso creativo.',
                    'category': 'professional'
                },
                '15:00': {
                    'content': 'Q&A profesional - Respondo sus preguntas sobre fotografía, video y trabajo freelance.',
                    'category': 'professional'
                }
            }
        }
        
        for day, posts in content_plan.items():
            for time_slot, post_info in posts.items():
                schedule.every().day.at(time_slot).do(
                    self.post_scheduled_content,
                    post_info['content'],
                    post_info['category']
                )
        
        print("📅 Contenido profesional programado")
        return len(content_plan)
    
    def post_scheduled_content(self, content: str, category: str):
        """Publica contenido programado"""
        try:
            formatted_post = self.setup.create_professional_post(content, category)
            self.client.send_post(formatted_post)
            print(f"✅ Post publicado: {content[:30]}...")
        except Exception as e:
            print(f"❌ Error publicando: {e}")

class ProfessionalAutoReplies:
    """Sistema de respuestas automáticas profesionales"""
    
    def __init__(self, client):
        self.client = client
        
    def setup_auto_replies(self):
        """Configura respuestas automáticas para consultas profesionales"""
        
        self.reply_templates = {
            'collaboration': """
¡Gracias por tu interés en colaborar! 🎬

Para propuestas profesionales:
📧 Email: tormentaworkmedia@gmail.com

Especifica:
• Tipo de proyecto
• Timeline estimado
• Presupuesto disponible

Te responderé pronto con disponibilidad y detalles.

#Collaboration #ProfessionalInquiry
            """,
            
            'pricing': """
Hola, gracias por preguntar sobre servicios profesionales. 💼

Mis servicios incluyen:
• Sesiones fotográficas
• Producción de video
• Contenido visual personalizado

📧 Para presupuesto detallado: tormentaworkmedia@gmail.com

Incluye detalles de tu proyecto para cotización precisa.

#Pricing #ProfessionalServices
            """,
            
            'portfolio': """
Puedes ver mi trabajo profesional en mi portfolio online.

🌐 [INSERTAR_LINK_PORTFOLIO_AQUÍ]

Para ejemplos específicos o caso de estudio:
📧 tormentaworkmedia@gmail.com

#Portfolio #ProfessionalWork
            """
        }
        
        print("✅ Respuestas automáticas configuradas")
        return True

# EJECUCIÓN PRINCIPAL
if __name__ == "__main__":
    print("🚀 INICIANDO CONFIGURACIÓN TORMENTA WORK MEDIA")
    print("=" * 60)
    
    # 1. Configuración inicial
    setup = TormentaWorkMediaSetup()
    result = setup.full_setup()
    
    if result:
        # 2. Configurar programador de contenido
        scheduler = ContentScheduler(setup.client)
        scheduled_count = scheduler.schedule_professional_content()
        
        # 3. Configurar respuestas automáticas
        auto_replies = ProfessionalAutoReplies(setup.client)
        auto_replies.setup_auto_replies()
        
        print(f"\n🎯 CONFIGURACIÓN COMPLETADA EXITOSAMENTE")
        print(f"   • Perfil: TORMENTA WORK MEDIA")
        print(f"   • Email: tormentaworkmedia@gmail.com")
        print(f"   • Handle: @tormentaworkmedia.bsky.social")
        print(f"   • Posts programados: {scheduled_count}")
        print(f"   • Respuestas automáticas: Activadas")
        
        # Mantener el programa corriendo para el scheduler
        print("\n⏰ Scheduler activo - Manteniendo programa ejecutándose...")
        try:
            while True:
                schedule.run_pending()
                time.sleep(1)
        except KeyboardInterrupt:
            print("\n👋 Programa terminado por el usuario")
    else:
        print("❌ La configuración falló. Revisa las credenciales.")
```

---

## 📁 ARCHIVO .ENV DE CONFIGURACIÓN

```bash
# ARCHIVO: .env
# Configuración para TORMENTA WORK MEDIA

BSKY_HANDLE_TORMENTA=tormentaworkmedia.bsky.social
BSKY_PASSWORD_TORMENTA=tu_password_de_aplicacion_aqui

# Configuraciones adicionales
CONTACT_EMAIL=tormentaworkmedia@gmail.com
PORTFOLIO_URL=tu_portfolio_profesional.com
BUSINESS_NAME=TORMENTA WORK MEDIA
```

---

## 🎯 INSTRUCCIONES DE USO

### **Pasos para Implementar:**

1. **Instalar Dependencias:**
```bash
pip install atproto schedule python-dotenv
```

2. **Crear Archivo .env:**
```bash
BSKY_HANDLE_TORMENTA=tormentaworkmedia.bsky.social
BSKY_PASSWORD_TORMENTA=tu_app_password_aqui
```

3. **Ejecutar Configuración:**
```bash
python tormentawork_bluesky_setup.py
```

4. **Configurar App Password:**
   - Ir a https://bsky.app/settings/app-passwords
   - Crear nuevo app password
   - Usarlo en el archivo .env

---

## 🔧 PERSONALIZACIÓN ADICIONAL

### **Para agregar tu portfolio real:**
```python
# En setup_professional_profile(), actualiza:
'🌐 Portfolio: https://tu-portfolio-real.com'

# En auto-replies, actualiza:
'🌐 https://tu-portfolio-real.com'
```

### **Para agregar redes sociales profesionales:**
```python
# En la descripción del perfil, añade:
"""
📱 Instagram: [@tu_instagram_profesional]
🐦 Twitter: [@tu_twitter_profesional] 
💼 LinkedIn: [tu_linkedin_url]
"""
```

---

## 📜 CERTIFICACIÓN DE IMPLEMENTACIÓN

**HASH:** `bluesky_tormentawork_impl_v5.3_jaff_23oct2025`  
**AUTOR:** José Agustín Fontán Varela  
**LABORATORIO:** PASAIA-LAB, Pasaia  
**FECHA:** 23/10/2025  

### **Características Implementadas:**
```python
✅ PERFIL PROFESIONAL:
   • Nombre: TORMENTA WORK MEDIA
   • Email: tormentaworkmedia@gmail.com  
   • Handle: @tormentaworkmedia.bsky.social
   • Descripción profesional completa

✅ SISTEMA DE CONTENIDO:
   • Etiquetado por categorías
   • Programación automática
   • Respuestas profesionales

✅ SEGURIDAD:
   • Uso de app passwords
   • Contenido apropiado para la plataforma
   • Enfoque profesional legítimo
```

---

**ESTADO: ✅ SCRIPT DE IMPLEMENTACIÓN ACTUALIZADO Y LISTO**

*"Este script configura una presencia profesional y efectiva en Bluesky para TORMENTA WORK MEDIA, manteniendo el compliance con las políticas de la plataforma y estableciendo una base sólida para networking profesional."*

--- DATOS PARTICULARES INEXACTOS POR SEGURIDAD ;)

Tormenta Work Free Intelligence + IA Free Intelligence Laboratory by José Agustín Fontán Varela is licensed under CC BY-NC-ND 4.0