herramientas.py

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

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.
    """
    print("Estoy en obtenUltimoTimestamp")
    print("La var last_timestamp es : ", last_timestamp)
    resultado = conexion_firebase.obtenDato('nowme', 'huggingface', last_timestamp)

    print(f"El resultado es: {resultado} y su tipo es {type(resultado)}... ")
    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(): 

    print("Obteniendo segundos disponibles...")

    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("Los segundos obtenidos de obtenSegundosDisponibles son: ", segundos_disponibles)

    # Restar los segundos
    nuevos_segundos_disponibles = segundos_disponibles - cuantos_segundos
    print("La resta o los nuevos_segundos_disponibles son: ", 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(): 
    timestamp_actual = int(time.time())    
    fecha_hora = datetime.fromtimestamp(timestamp_actual)
    fecha_hora_legible = fecha_hora.strftime('%Y-%m-%d %H:%M:%S')
    return fecha_hora_legible

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()

    print(f"Estoy comparando fecha registro {fecha_registro} con fecha actual {fecha_actual}...")
    
    # Verificar si las fechas son diferentes
    return fecha_actual > fecha_registro