herramientas.py

from datetime import datetime
from datetime import datetime
import conexion_firebase
import globales
import pytz
import time
import random

if globales.servidor == "moibe":
    segundos = "segundos_dev"
    last_timestamp = "last_timestamp_dev"
else: 
    segundos = "segundos_prod"
    last_timestamp = "last_timestamp_prod"

def obtenUltimoTimestamp():
    """
    Obtiene el último timestamp de renovación guardado.
    """
    resultado = conexion_firebase.obtenDato('nowme', 'huggingface', last_timestamp)
    print("Obten último timestamp obtenido: ", resultado)    
    
    return resultado
    
def obtenSegundosDisponibles(): 

    if esDiaSiguiente() == True:
        renuevaSegundosDisponibles()
        renuevaModeloPrincipal()

    #Finalmente obten los segundos disponibles después de las operaciones.
    return conexion_firebase.obtenDato('nowme', 'huggingface', segundos)

def obtenSegundosDisponiblesInference(): 

    # if esDiaSiguiente() == True:
    #     renuevaSegundosDisponibles()
    #     renuevaModeloPrincipal()

    #Finalmente obten los segundos disponibles después de las operaciones.
    return conexion_firebase.obtenDato('nowme', 'huggingface', 'hfInference')
    
    
def renuevaSegundosDisponibles():

    #Segundos de cuota total gratuita disponibles al momento.
    conexion_firebase.editaDato('nowme', 'huggingface', segundos, globales.quota)
    renuevaTimestampActual()

def renuevaTimestampActual(): 

    timestamp_actual = imprimeTimeNowFixed16h()
    print("Ésto es el timestamp now de la renovación...: ", timestamp_actual)
    conexion_firebase.editaDato('nowme', 'huggingface', last_timestamp, timestamp_actual)    

def restaSegundosGPU(cuantos_segundos):
    """
    Lee el número de segundos disponibles,
    resta los segundos dados como parámetro y guarda el nuevo valor en el archivo.
    """

    segundos_disponibles = obtenSegundosDisponibles()    
    print("Segundos disponibles: ", segundos_disponibles)

    # Restar los segundos
    nuevos_segundos_disponibles = segundos_disponibles - cuantos_segundos
    print("Segundos disponibles ahora: ", nuevos_segundos_disponibles)
    conexion_firebase.editaDato('nowme', 'huggingface', segundos, nuevos_segundos_disponibles)

def restaSegundosInference(cuantos_segundos):
    """
    Lee el número de segundos disponibles desde seconds_available.txt,
    resta los segundos dados como parámetro y guarda el nuevo valor en el archivo.
    """

    segundos_disponibles = obtenSegundosDisponiblesInference()    
    print("Segundos disponibles Inference: ", segundos_disponibles)
    
    # Restar los segundos
    nuevos_segundos_disponibles = segundos_disponibles - cuantos_segundos
    print("Segundos disponibles ahora en restaSegundosInference: ", nuevos_segundos_disponibles)
    conexion_firebase.editaDato('nowme', 'huggingface', 'hfInference', nuevos_segundos_disponibles)    

def modificaModeloActual(nuevo_modelo):
    """
    Actualiza el archivo archivos/modelo_actual.txt con el modelo funcional en caso de
    problemas con el actual.
    """

    modelo_actual = conexion_firebase.obtenDato('nowme', 'huggingface', 'modelo_actual')
    conexion_firebase.editaDato('nowme', 'huggingface', 'modelo_actual', nuevo_modelo)
    print(f"Se actualizó el modelo actual: {modelo_actual} por {nuevo_modelo}.")

def renuevaModeloPrincipal():
    #Obten el modelo principal (default).   
    modelo_principal = conexion_firebase.obtenDato('nowme', 'huggingface', 'modelo_principal')
    #Asignalo como modelo actual.
    conexion_firebase.editaDato('nowme', 'huggingface', 'modelo_actual', modelo_principal)

def imprimeTimeNow(): 
    """
    Devuelve la fecha y hora actual en la zona horaria de la Ciudad de México (GMT-6).
    """
    # 1. Definir la zona horaria de la Ciudad de México
    # Puedes usar 'America/Mexico_City' para que pytz maneje el horario de verano automáticamente.
    mexico_city_tz = pytz.timezone('America/Mexico_City')

    # 2. Obtener la hora actual en UTC
    utc_now = datetime.now(pytz.utc)

    # 3. Convertir la hora UTC a la zona horaria deseada
    mexico_city_now = utc_now.astimezone(mexico_city_tz)

    # 4. Formatear la fecha y hora
    # El formato que deseas es "YYYY-MM-DD HH:MM:SS"
    formatted_time = mexico_city_now.strftime("%Y-%m-%d %H:%M:%S")

    return formatted_time

def imprimeTimeNowFixed16h():
    """
    Devuelve la fecha actual con la hora fijada a las 16:00:00 (4 PM)
    en la zona horaria de la Ciudad de México (GMT-6).
    """
    # 1. Definir la zona horaria de la Ciudad de México
    mexico_city_tz = pytz.timezone('America/Mexico_City')

    # 2. Obtener la fecha y hora actual en UTC
    utc_now = datetime.now(pytz.utc)

    # 3. Convertir la hora UTC a la zona horaria de la Ciudad de México
    #    Esto nos da la fecha correcta (año, mes, día) para esa zona.
    mexico_city_aware_dt = utc_now.astimezone(mexico_city_tz)

    # 4. Crear un nuevo objeto datetime con la fecha obtenida
    #    pero con la hora fijada a las 16:00:00
    fixed_time_dt = mexico_city_tz.localize(
        datetime(
            mexico_city_aware_dt.year,
            mexico_city_aware_dt.month,
            mexico_city_aware_dt.day,
            16,  # Hora fijada a las 16 (4 PM)
            0,   # Minutos fijados a 0
            0    # Segundos fijados a 0
        )
    )
    
    # Nota sobre .localize() vs .astimezone():
    # .localize() se usa para tomar un datetime "naive" (sin zona horaria)
    # y asignarle una zona horaria.
    # .astimezone() se usa para convertir un datetime "timezone-aware"
    # de una zona horaria a otra.
    # Aquí creamos un datetime "naive" con la fecha correcta y la hora 16:00:00
    # y luego lo "localizamos" en la zona horaria de México.


    # 5. Formatear la fecha y hora
    formatted_time = fixed_time_dt.strftime("%Y-%m-%d %H:%M:%S")

    return formatted_time

def esDiaSiguiente(): 
    """
    Compara dos timestamps Unix y devuelve True si el día de timestamp_actual
    es diferente al día de timestamp_registro.

    Args:
        timestamp_registro (int): Timestamp Unix del registro original (en segundos).
        timestamp_actual (int): Timestamp Unix actual (en segundos).

    Returns:
        bool: True si el día de timestamp_actual es diferente al día de
              timestamp_registro, False si es el mismo día.
    """

    #Obtiene el último registro de fecha de la base de firestore.
    fecha_registro_dt = obtenUltimoTimestamp()   
    
    print("Primero, el último timestamp obtenido de base es: ", fecha_registro_dt)
    print("Y su tipo es: ", type(fecha_registro_dt))
   
    #Timestamp actual
    fecha_actual_dt = imprimeTimeNow()
    print("Segundo, la fecha_actual_dt quedó como: ", fecha_actual_dt)
    print("Y su tipo es: ", type(fecha_actual_dt))
    

    formato = "%Y-%m-%d %H:%M:%S"
    datetime_obj_1 = datetime.strptime(fecha_registro_dt, formato)
    datetime_obj_2 = datetime.strptime(fecha_actual_dt, formato)   
        
    # Extraer solo la fecha de los objetos datetime
    fecha_registro = datetime_obj_1.date()
    #print("Primera extracción: ", fecha_registro)
    fecha_actual = datetime_obj_2.date()
    #print("Segunda extracción: ", fecha_actual)    
    

    # Verificar si las fechas son diferentes
    resultado = fecha_actual > fecha_registro
    print("Resultado de resta de fechas: ", resultado)    
    
    return resultado

def getFluxServer(): 
    print("In getFluxServer...")
    server_keys = list(globales.SERVER_NAMES.values())
    random_value = random.choice(server_keys)
    print("Random key: ", random_value)
    
    return random_value