[ADDED] Script para actualización automatizada de tarifas via Perplexity

Se añade script rate_update.py para:
- Analizar archivos .rate en la carpeta de configuración
- Consultar a la API de Perplexity para obtener tarifas actualizadas
- Guardar valores numéricos con 2 decimales en los archivos correspondientes
- Preservar archivos especiales como kdevs.rate sin modificarlos
- Soportar diferentes tipos de programadores y regiones

🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>

bin/rate_update.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+Rate Update Script
+
+Este script actualiza las tarifas por hora de diferentes tipos de programadores
+por región utilizando la API de Perplexity para obtener datos actualizados.
+
+Licencia: AGPL-3.0
+Modified: 2025-03-12
+"""
+
+import os
+import glob
+import re
+import json
+import logging
+import requests
+import sys
+from pathlib import Path
+
+# Configuración de logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger('rate_update')
+
+# Directorio base del proyecto
+BASE_DIR = Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+CONFIG_DIR = BASE_DIR / 'bin' / 'config'
+
+# Archivo de configuración para el modelo de IA
+MODEL_CONFIG_FILE = CONFIG_DIR / 'rate_model.ai'
+
+def get_ai_model():
+    """Obtener el modelo de IA configurado."""
+    try:
+        with open(MODEL_CONFIG_FILE, 'r') as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        logger.warning(f"Archivo de configuración {MODEL_CONFIG_FILE} no encontrado. Usando modelo predeterminado 'o1'.")
+        return "o1"
+
+def get_perplexity_api_key():
+    """Obtener la clave API de Perplexity desde una variable de entorno."""
+    api_key = os.environ.get('PERPLEXITY_API_KEY')
+    if not api_key:
+        logger.error("No se encontró la clave API de Perplexity. Establezca la variable de entorno PERPLEXITY_API_KEY.")
+        sys.exit(1)
+    return api_key
+
+def query_perplexity(prompt, model="o1"):
+    """Realizar una consulta a la API de Perplexity."""
+    api_key = get_perplexity_api_key()
+    
+    url = "https://api.perplexity.ai/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "model": model,
+        "messages": [
+            {
+                "role": "system",
+                "content": "You are a helpful assistant that provides accurate salary information for developers worldwide. Respond only with numeric values in USD with 2 decimal places."
+            },
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ],
+        "max_tokens": 100
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        result = response.json()
+        
+        # Extraer solo el valor numérico de la respuesta
+        content = result.get('choices', [{}])[0].get('message', {}).get('content', '')
+        # Intentar encontrar un número con 2 decimales en la respuesta
+        match = re.search(r'\$?(\d+\.\d{2})', content)
+        if match:
+            return float(match.group(1))
+        
+        # Si no encuentra un formato exacto, intentar convertir toda la respuesta a float
+        try:
+            # Eliminar cualquier símbolo de moneda y espacios
+            cleaned_content = re.sub(r'[^\d.]', '', content)
+            return round(float(cleaned_content), 2)
+        except ValueError:
+            logger.error(f"No se pudo extraer un valor numérico de la respuesta: {content}")
+            return None
+            
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error al conectar con la API de Perplexity: {e}")
+        return None
+
+def parse_rate_filename(filename):
+    """
+    Analiza el nombre del archivo de tarifa para extraer el tipo de programador y la región.
+    Formato: [tipo_de_programador]_[código_país].rate
+    """
+    base_name = os.path.basename(filename)
+    match = re.match(r'([a-z]+)_([a-z]{2})\.rate$', base_name)
+    
+    if not match:
+        # Para archivos como kdevs.rate que no siguen el patrón estándar
+        if base_name.endswith('.rate'):
+            programmer_type = base_name.replace('.rate', '')
+            return programmer_type, None
+        return None, None
+    
+    programmer_type, region_code = match.groups()
+    return programmer_type, region_code
+
+def generate_prompt(programmer_type, region_code):
+    """Genera un prompt para consultar a Perplexity sobre la tarifa horaria."""
+    region_map = {
+        'ww': 'mundial',
+        'la': 'Latinoamérica',
+        'pa': 'Panamá',
+        'co': 'Colombia',
+        'mx': 'México',
+        'ar': 'Argentina',
+        'br': 'Brasil',
+        'cl': 'Chile',
+        'pe': 'Perú',
+        'ec': 'Ecuador',
+        'us': 'Estados Unidos',
+        'ca': 'Canadá',
+        'uk': 'Reino Unido',
+        'de': 'Alemania',
+        'fr': 'Francia',
+        'es': 'España',
+        'it': 'Italia'
+    }
+    
+    # Archivos especiales como kdevs.rate se manejan de forma diferente
+    if programmer_type == 'kdevs':
+        # Simplemente mantener el valor actual para kdevs.rate
+        return None
+    
+    programmer_map = {
+        'bash': 'programador de scripts Bash/Shell',
+        'python': 'desarrollador Python',
+        'fullstack': 'desarrollador Full Stack',
+        'frontend': 'desarrollador Frontend',
+        'backend': 'desarrollador Backend',
+        'devops': 'ingeniero DevOps',
+        'mobile': 'desarrollador de aplicaciones móviles',
+        'java': 'desarrollador Java',
+        'php': 'desarrollador PHP',
+        'ruby': 'desarrollador Ruby',
+        'dotnet': 'desarrollador .NET',
+        'data': 'científico de datos',
+        'ml': 'ingeniero de Machine Learning',
+        'cloud': 'arquitecto Cloud',
+        'odoo': 'desarrollador Odoo'
+    }
+    
+    region_name = region_map.get(region_code, f'región con código {region_code}')
+    programmer_description = programmer_map.get(programmer_type, f'desarrollador {programmer_type}')
+    
+    prompt = f"¿Cuál es la tarifa por hora promedio en dólares estadounidenses (USD) para un {programmer_description} en {region_name} en 2025? Responde solo con el valor numérico con dos decimales."
+    
+    return prompt
+
+def update_rate_files():
+    """Actualiza los archivos de tarifas con datos de Perplexity."""
+    # Obtener modelo configurado
+    model = get_ai_model()
+    logger.info(f"Usando modelo de IA: {model}")
+    
+    # Buscar todos los archivos .rate
+    rate_files = glob.glob(str(CONFIG_DIR / '*.rate'))
+    logger.info(f"Encontrados {len(rate_files)} archivos de tarifas para actualizar.")
+    
+    for rate_file in rate_files:
+        programmer_type, region_code = parse_rate_filename(rate_file)
+        
+        if programmer_type is None:
+            logger.warning(f"No se pudo analizar el nombre del archivo: {rate_file}, saltando.")
+            continue
+        
+        # Si es un archivo especial como kdevs.rate
+        if region_code is None:
+            prompt = generate_prompt(programmer_type, None)
+            # Saltamos los archivos especiales que no necesitan actualización
+            if prompt is None:
+                logger.info(f"Saltando archivo especial: {os.path.basename(rate_file)}")
+                continue
+        else:
+            prompt = generate_prompt(programmer_type, region_code)
+        
+        logger.info(f"Consultando tarifa para {programmer_type}" + 
+                   (f" en región {region_code}" if region_code else ""))
+        
+        # Consultar a Perplexity
+        rate = query_perplexity(prompt, model)
+        
+        if rate is not None:
+            # Guardar el resultado en el archivo
+            with open(rate_file, 'w') as f:
+                f.write(f"{rate:.2f}\n")
+            logger.info(f"Actualizado {os.path.basename(rate_file)} con valor: {rate:.2f}")
+        else:
+            logger.error(f"No se pudo obtener la tarifa para {programmer_type}" + 
+                        (f" en región {region_code}" if region_code else ""))
+
+if __name__ == "__main__":
+    logger.info("Iniciando actualización de tarifas...")
+    update_rate_files()
+    logger.info("Proceso de actualización de tarifas completado.")