[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>
This commit is contained in:
Mauro Rosero P. 2025-03-12 07:16:25 -05:00
parent be20614dfe
commit 7ce3171a0e
Signed by: mrosero
GPG key ID: 83BD2A5F674B7E26

218
bin/rate_update.py Executable file
View file

@ -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.")