Skip to content
The Chat Archive
o1-preview-2024-09-12· OpenAI WildChat-4.8M (AI2)

esto esta bien ? Este es un ejemplo que utiliza la API de websockets para saber cuándo…

  1. User

    esto esta bien ?

    Este es un ejemplo que utiliza la API de websockets para saber cuándo se ha completado la ejecución de un prompt.

    Una vez que la ejecución del prompt ha finalizado, descarga las imágenes usando el endpoint /history.

    import websocket import uuid import json import urllib.request import urllib.parse import requests

    server_address = "127.0.0.1:8188" client_id = str(uuid.uuid4())

    def queue_prompt(workflow): p = {"workflow": workflow, "client_id": client_id} data = json.dumps(p).encode('utf-8') print(f"Enviando prompt: {p}") # Salida para depuración headers = {'Content-Type': 'application/json'} req = urllib.request.Request(f"http://{server_address}/prompt", data=data, headers=headers) return json.loads(urllib.request.urlopen(req).read())

    def get_image(filename, subfolder, folder_type): data = {"filename": filename, "subfolder": subfolder, "type": folder_type} url_values = urllib.parse.urlencode(data) with urllib.request.urlopen(f"http://{server_address}/view?{url_values}") as response: return response.read()

    def get_history(prompt_id): with urllib.request.urlopen(f"http://{server_address}/history/{prompt_id}") as response: return json.loads(response.read())

    def get_images(ws, workflow): prompt_id = queue_prompt(workflow)['prompt_id'] output_images = {} while True: out = ws.recv() if isinstance(out, str): message = json.loads(out) if message['type'] == 'executing': data = message['data'] if data['node'] is None and data['prompt_id'] == prompt_id: break # La ejecución ha finalizado else: continue # Las previsualizaciones son datos binarios

    history = get_history(prompt_id)[prompt_id]
    for node_id in history['outputs']:
        node_output = history['outputs'][node_id]
        if 'images' in node_output:
            images_output = []
            for image in node_output['images']:
                image_data = get_image(image['filename'], image['subfolder'], image['type'])
                images_output.append(image_data)
            output_images[node_id] = images_output
    
    return output_images
    

    def upload_file(file, subfolder="", overwrite=False): try: # Envolver el archivo en formdata para que incluya el nombre del archivo body = {"image": file} data = {}

        if overwrite:
            data["overwrite"] = "true"
    
        if subfolder:
            data["subfolder"] = subfolder
    
        resp = requests.post(f"http://{server_address}/upload/image", files=body, data=data)
    
        if resp.status_code == 200:
            data = resp.json()
            # Agregar el archivo a la lista desplegable y actualizar el valor del widget
            path = data["name"]
            if "subfolder" in data and data["subfolder"]:
                path = f"{data['subfolder']}/{path}"
            return path
        else:
            print(f"{resp.status_code} - {resp.reason}")
    except Exception as error:
        print(error)
        return None
    

    Semilla aleatoria

    seed = 7777777777777777

    Subir una imagen

    with open("example.png", "rb") as f: comfyui_path_image = upload_file(f, "", True)

    Cargar el workflow desde un archivo

    with open("c:\Users\saka\workflow.json", "r", encoding="utf-8") as f: workflow_data = f.read()

    workflow = json.loads(workflow_data)

    Agregar un nodo LoadImage con el ID "11"

    workflow["11"] = { "inputs": { "image": comfyui_path_image }, "class_type": "LoadImage", "_meta": { "title": "Load Image" } }

    Ajustar las conexiones en tu workflow para incluir el nuevo nodo

    Por ejemplo, si deseas usar la imagen cargada en el nodo KSampler (ID "3")

    workflow["3"]["inputs"]["latent_image"] = ["11", 0]

    Establecer el texto del prompt para nuestros nodos CLIPTextEncode positivos y negativos

    workflow["6"]["inputs"]["text"] = "masterpiece, best quality, a wide angle shot from the front of a girl posing on a bench in a beautiful meadow, :o face, short and rose hair, perfect legs, perfect arms, perfect eyes, perfect body, perfect feet, blue day sky, shorts, beautiful eyes, sharp focus, full body shot" workflow["7"]["inputs"]["text"] = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry, deformed, nsfw, deformed legs"

    Establecer la semilla para nuestro nodo KSampler

    workflow["3"]["inputs"]["seed"] = seed

    Establecer el modelo

    workflow["4"]["inputs"]["ckpt_name"] = "E:\pinokio\api\comfy.git\app\models\checkpoints\flux1-schnell-fp8.safetensors"

    Conexión websocket

    ws = websocket.create_connection(f"ws://{server_address}/ws?clientId={client_id}") images = get_images(ws, workflow)

    Guardar las imágenes de salida

    for node_id in images: for image_data in images[node_id]: from PIL import Image import io image = Image.open(io.BytesIO(image_data)) image.save(f"{node_id}-{seed}.png")

    es para conectar con la api de comfyui

  2. Assistant

    ¡Hola! He revisado tu código y, en general, parece que estás en el camino correcto para conectarte y utilizar la API de ComfyUI. Sin embargo, hay algunos aspectos que podrías ajustar para mejorar el funcionamiento y asegurar que todo esté bien configurado. A continuación, te proporcionaré una revisión detallada y algunas sugerencias:

    Análisis del código:

    1. Importaciones y configuraciones iniciales:

      import websocket
      import uuid
      import json
      import urllib.request
      import urllib.parse
      import requests
      

      Las importaciones parecen correctas para las operaciones que estás realizando.

      server_address = "127.0.0.1:8188"
      client_id = str(uuid.uuid4())
      

      Estás configurando la dirección del servidor y generando un client_id único, lo cual es apropiado.

    2. Funciones definidas:

      • queue_prompt(workflow): Envía un prompt al servidor.

        Asegúrate de que el endpoint /prompt esté disponible en tu instancia de ComfyUI y que acepta solicitudes POST con el formato que estás enviando.

      • get_image(filename, subfolder, folder_type): Descarga una imagen desde el servidor.

        Esta función parece correcta, utiliza el endpoint /view con los parámetros adecuados.

      • get_history(prompt_id): Obtiene el historial de ejecución de un prompt específico.

        Nuevamente, verifica que el endpoint /history/{prompt_id} esté disponible y que devuelve la información en el formato esperado.

      • get_images(ws, workflow):

        Aquí es donde envías el workflow y esperas hasta que la ejecución haya finalizado.

        prompt_id = queue_prompt(workflow)['prompt_id']
        

        Te recomendaría añadir un manejo de excepciones aquí en caso de que la respuesta no contenga 'prompt_id'.

        while True:
            out = ws.recv()
            if isinstance(out, str):
                message = json.loads(out)
                if message['type'] == 'executing':
                    data = message['data']
                    if data['node'] is None and data['prompt_id'] == prompt_id:
                        break  # La ejecución ha finalizado
        

        Este bucle espera hasta que recibe un mensaje de tipo 'executing' con data['node'] is None, lo cual parece ser tu señal para determinar que la ejecución ha finalizado. Asegúrate de que el servidor envía estos mensajes con esta estructura.

        Después, obtienes el historial y descargas las imágenes de salida.

      • upload_file(file, subfolder="", overwrite=False):

        Esta función sube un archivo al servidor. Asegúrate de que el endpoint /upload/image está configurado para aceptar este tipo de solicitudes.

    3. Carga y modificación del workflow:

      # Cargar el workflow desde un archivo
      with open("c:\\Users\\saka\\workflow.json", "r", encoding="utf-8") as f:
          workflow_data = f.read()
      

      Asegúrate de que la ruta al archivo workflow.json es correcta y que el archivo existe en esa ubicación.

      workflow = json.loads(workflow_data)
      

      Verifica que el contenido del archivo sea un JSON válido.

      • Añadir el nodo LoadImage:

        workflow["11"] = {
            "inputs": {
                "image": comfyui_path_image
            },
            "class_type": "LoadImage",
            "_meta": {
                "title": "Load Image"
            }
        }
        

        Estás añadiendo un nuevo nodo al workflow. Asegúrate de que el ID "11" no entra en conflicto con otros IDs existentes en el workflow.

      • Ajustar conexiones:

        workflow["3"]["inputs"]["latent_image"] = ["11", 0]
        

        Esto conecta la salida del nodo "11" a la entrada latent_image del nodo "3". Verifica que el nodo "3" espera recibir esta entrada y que el índice 0 es correcto.

      • Establecer los prompts:

        workflow["6"]["inputs"]["text"] = "..."  # Texto positivo
        workflow["7"]["inputs"]["text"] = "..."  # Texto negativo
        

        Asegúrate de que los nodos "6" y "7" son los correctos para establecer textos de prompt y que el texto es adecuado para tu aplicación.

      • Establecer la semilla:

        workflow["3"]["inputs"]["seed"] = seed
        

        Asumiendo que el nodo "3" es un KSampler, esto debería funcionar.

      • Establecer el modelo:

        workflow["4"]["inputs"]["ckpt_name"] = "E:\\pinokio\\api\\comfy.git\\app\\models\\checkpoints\\flux1-schnell-fp8.safetensors"
        

        Verifica que la ruta al modelo es correcta y accesible desde donde se está ejecutando ComfyUI.

    4. Conexión WebSocket y obtención de imágenes:

      ws = websocket.create_connection(f"ws://{server_address}/ws?clientId={client_id}")
      images = get_images(ws, workflow)
      

      Te estás conectando al WebSocket y obteniendo las imágenes generadas. Asegúrate de que el endpoint /ws está configurado para proporcionar los mensajes que tu función get_images espera.

    5. Guardar las imágenes de salida:

      for node_id in images:
          for image_data in images[node_id]:
              from PIL import Image
              import io
              image = Image.open(io.BytesIO(image_data))
              image.save(f"{node_id}-{seed}.png")
      

      Este código guarda las imágenes descargadas con un nombre que incluye el node_id y la seed.

    Sugerencias y consideraciones:

    • Manejo de excepciones:

      A lo largo del código, sería recomendable añadir bloques try-except para capturar y manejar posibles excepciones, especialmente en operaciones de red y lectura/escritura de archivos.

    • Verificación de respuestas:

      Al realizar solicitudes al servidor o al recibir mensajes del WebSocket, verifica que las respuestas contienen los datos esperados antes de intentar acceder a ellos. Por ejemplo, comprobar si 'prompt_id' está en la respuesta de queue_prompt.

    • Configuración de rutas y parámetros:

      • Asegúrate de que todas las rutas de archivos (como "c:\\Users\\saka\\workflow.json" y la ruta al modelo) son correctas y accesibles desde el entorno donde se ejecuta el código.
      • Considera parametrizar estas rutas o utilizar variables de entorno para mayor flexibilidad.
    • IDs de nodos:

      • Cuando agregas un nuevo nodo con ID "11", verifica que este ID no exista ya en el workflow original.
      • Es posible que quieras generar IDs únicos o manejar los IDs de manera más dinámica.
    • Documentación y comentarios:

      • Aunque ya tienes comentarios en el código, añadir más detalles puede ayudarte a ti y a otros a entender mejor cada parte del código en el futuro.
    • Dependencias y versiones:

      • Asegúrate de que todas las librerías y dependencias que utilizas están instaladas en tu entorno y son compatibles entre sí.
      • Especifica las versiones de las librerías si es necesario, especialmente si compartes el código con otros.
    • Seguridad:

      • Si este código se va a utilizar en un entorno de producción o compartido, considera aspectos de seguridad como la validación de datos y la protección contra posibles inyecciones o ataques.

    Conclusión:

    En general, tu código parece bien estructurado y sigue una lógica adecuada para interactuar con la API de ComfyUI. Con las verificaciones adicionales y ajustes mencionados, deberías poder conectarte y obtener los resultados esperados.

    Si encuentras algún error específico al ejecutar el código, por favor proporciónalo para que pueda ayudarte a resolverlo. ¡Espero que esta revisión te sea de ayuda!