herramientas.py

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

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)

    return resultado

def esNuevoDia():
    """
    Compara dos timestamps (en formato string ISO) y devuelve True si han
    pasado más de 24 horas entre ellos, False en caso contrario.
    """

    timestamp_original = obtenUltimoTimestamp()
    timestamp_actual = int(time.time())

    try:
        segundos_en_24_horas = 24 * 60 * 60
        diferencia_en_segundos = abs(timestamp_actual - timestamp_original)
        return diferencia_en_segundos > segundos_en_24_horas
    except ValueError:
        print("Error: Formato de timestamp incorrecto.")
        return False
    
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 renuevaSegundosDisponibles():

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

def renuevaTimestampActual(): 

    timestamp_actual = int(time.time())
    conexion_firebase.editaDato('nowme', 'huggingface', last_timestamp, timestamp_actual)    

def restaSegundosGPU(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 = 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 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 imprimeTime(): 
    """
    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 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.
    """

    # Convertir los timestamps Unix a objetos datetime (zona horaria local)
    fecha_registro_dt = datetime.fromtimestamp(obtenUltimoTimestamp())
    
   
    #fecha_actual_dt = datetime.fromtimestamp(int(time.time())) #Timestamp actual.
    fecha_actual_dt = datetime.fromtimestamp(int(time.time()))
        
    # Extraer solo la fecha de los objetos datetime
    fecha_registro = fecha_registro_dt.date()
    fecha_actual = fecha_actual_dt.date()
    
    # Verificar si las fechas son diferentes
    return fecha_actual > fecha_registro