herramientas.py

import time
from datetime import datetime
from datetime import datetime, date, timedelta
import conexion_firebase

def obtenUltimoTimestamp():
    """
    Obtiene el último timestamp de renovación guardado.
    """

    resultado = conexion_firebase.obtenDato('nowme', 'huggingface', 'last_timestamp')
    return resultado

    #Antes se hacía con archivos estáticos.
    # try:
    #     archivo_ruta = "archivos/last_timestamp.txt"
    #     with open(archivo_ruta, 'r') as archivo:
    #         contenido = archivo.readline().strip()
    #         ultimo_timestamp = int(contenido)
    #         return ultimo_timestamp
    # except FileNotFoundError:
    #     print(f"Error: El archivo '{archivo_ruta}' no fue encontrado.")
    #     return 
    # except ValueError:
    #     print(f"Error: El contenido del archivo '{archivo_ruta}' no es un número entero válido.")
    #     return

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

    # try:
    #     archivo_ruta = "archivos/seconds_available.txt"
    #     # Leer el número actual de segundos disponibles
    #     with open(archivo_ruta, 'r') as archivo:
    #         contenido = archivo.readline().strip()
    #         segundos_disponibles = int(contenido)
    #         return segundos_disponibles
    # except FileNotFoundError:
    #     print(f"Error: El archivo '{archivo_ruta}' no fue encontrado.")
    #     return
    # except ValueError:
    #     print(f"Error: El contenido del archivo '{archivo_ruta}' no es un número entero válido.")
    #     return
    
def renuevaSegundosDisponibles():

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

    # Guardar el nuevo número en el archivo
    # try:
    #     archivo_ruta = "archivos/seconds_available.txt"
    #     with open(archivo_ruta, 'w') as archivo:
    #         archivo.write(str(quota_total))
    #     print(f"Se renovaron los {quota_total} segundos disponibles.")
    # except Exception as e:
    #     print(f"Error al escribir en el archivo '{archivo_ruta}': {e}") 

def renuevaTimestampActual(): 

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

def restaSegundosGPU(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.
    """

    print("Estoy en resta segundos...")
    segundos_disponibles = obtenSegundosDisponibles()    

    # Restar los segundos
    nuevos_segundos_disponibles = segundos_disponibles - segundos
    conexion_firebase.editaDato('nowme', 'huggingface', 'segundos', nuevos_segundos_disponibles)

    # # Guardar el nuevo número en el archivo
    # try:
    #     archivo_ruta = "archivos/seconds_available.txt"
    #     with open(archivo_ruta, 'w') as archivo:
    #         archivo.write(str(nuevos_segundos_disponibles))
    #     print(f"Se restaron {segundos} segundos. Ahora quedan {nuevos_segundos_disponibles} segundos disponibles.")
    # except Exception as e:
    #     print(f"Error al escribir en el archivo '{archivo_ruta}': {e}") 

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

    print("Estoy en actualiza modelo 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}.")

    # Guardar el nuevo número en el archivo
    # try:
    #     archivo_ruta = "archivos/modelo_actual.txt"
    #     with open(archivo_ruta, 'w') as archivo:
    #         archivo.write(nuevo_modelo)        
    # except Exception as e:
    #     print(f"Error al escribir en el archivo '{archivo_ruta}': {e}") 

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.

    # 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