# 🛠️ 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
