?Inicio • ?Características • ?Instalación • ?Uso • Documentación • ?API
✅Requisitos • CLI • ?Docker • ?Limitaciones
Biblioteca Python para programar mediante programación los flujos de trabajo de ComfyUI a través de la API de ComfyUI
Rama | Estado de construcción | Se compromete desde | Última confirmación |
---|---|---|---|
Maestro | |||
Desarrollar |
ComfyUI API Endpoint <| <= Comfy Catapult <=> HTTP Server <| <= Public users
<| <|
<| Your python program <| Your Webui/JS frontend
<| <|
<| Your workflows <|
<| Your HTTP server <|
Comfy Catapult es una biblioteca para programar y ejecutar flujos de trabajo de ComfyUI desde un programa Python, a través del punto final API existente. ComfyUI normalmente funciona alojando este punto final API para su interfaz de usuario.
Esto le facilita crear flujos de trabajo a través de la interfaz de usuario y luego usarlos desde un programa.
# Inside your environment:
# From pypi:
pip install comfy_catapult
# From git:
pip install git+https://github.com/realazthat/[email protected]
Proyecto | Envoltorio de API ComfyUI | Subcontratar el backend | Distribuir ejecución | Ajustar flujo de trabajo | Estudio |
---|---|---|---|---|---|
CushyStudio | ? | ? | ? | ? | Sí |
Kit de herramientas de servicio ComfyUI | incógnita | ? | ? | Sí | ? |
CómodoUI_NetDist | incógnita | ? | Sí | ? | ? |
ComfyUI script_examples | Sí | No | No | No | No |
cómodaui-python-api | ? | ? | ? | Sí | ? |
implementación cómoda de UI | ? | ? | ? | Sí | ? |
Cómoda extensión de UI a Python | ? | ? | ? | Sí | ? |
Cómodo script | ? | ? | ? | Sí | ? |
hordelib | ? | Sí | ? | ? | ? |
nube cómodaui | ? | Sí | ? | ? | ? |
corredor_cómodo | ? | ? | ? | ? | ? |
ComfyUI-ComfyRun | ? | ? | ? | ? | ? |
De comfy_catapult/catapult_base.py
:
async def Catapult (
self ,
* ,
job_id : JobID ,
prepared_workflow : dict ,
important : Sequence [ APINodeID ],
use_future_api : Literal [ True ],
job_debug_path : Optional [ Path ] = None
) -> Tuple [ JobStatus , 'asyncio.Future[dict]' ]:
De examples/sdxlturbo_example_catapulter.py
:
class ExampleWorkflowInfo :
# Direct wrapper around the ComfyUI API.
client : ComfyAPIClientBase
# Job scheduler (the main point of this library).
catapult : ComfyCatapultBase
# Something to help with retrieving files from the ComfyUI storage.
remote : RemoteFileAPIBase
comfy_api_url : str
# This should be the workflow json as a dict.
workflow_template_dict : dict
# This should begin as a deep copy of the template.
workflow_dict : dict
# This will hold the node ids that we must have results for.
important : List [ APINodeID ]
# Make this any string unique to this job.
job_id : str
# When the job is complete, this will be the `/history` json/dictionary for
# this job.
job_history_dict : Optional [ dict ]
# These are inputs that modify this particular workflow.
ckpt_name : Optional [ str ]
positive_prompt : str
negative_prompt : str
# For this particular workflow, this will define the path to the output image.
output_path : Path
async def RunExampleWorkflow ( * , job_info : ExampleWorkflowInfo ):
# You have to write this function, to change the workflow_dict as you like.
await PrepareWorkflow ( job_info = job_info )
job_id : str = job_info . job_id
workflow_dict : dict = job_info . workflow_dict
important : List [ APINodeID ] = job_info . important
# Here the magic happens, the job is submitted to the ComfyUI server.
status , future = await job_info . catapult . Catapult (
job_id = job_id ,
prepared_workflow = workflow_dict ,
important = important ,
use_future_api = True )
# Wait for the job to complete.
while not future . done ():
status , _ = await job_info . catapult . GetStatus ( job_id = job_id )
print ( f'status: { status } ' , file = sys . stderr )
await asyncio . sleep ( 3 )
job_info . job_history_dict = await future
# Now that the job is done, you have to write something that will go and get
# the results you care about, if necessary.
await DownloadResults ( job_info = job_info )
En la interfaz web de ComfyUI:
Enable Dev mode Options
.Save (API format)
. opciones execute
:
Uso de ejemplo:
python -m comfy_catapult.cli
execute --workflow-path ./test_data/sdxlturbo_example_api.json
3.8.0, 3.9.0, 3.10.0, 3.11.0, 3.12.0
, probado en el flujo de trabajo de GitHub Actions (./.github/workflows/build-and-test.yml). Las imágenes de Docker se publican en ghcr.io/realazthat/comfy-catapult en cada etiqueta.
# Use the published images at https://ghcr.io/realazthat/comfy-catapult.
docker run --rm --tty ghcr.io/realazthat/comfy-catapult:v3.0.0 --help
# /data in the docker image is the working directory, so paths are simpler.
docker run --rm --tty
-v " ${PWD} :/data "
-e " COMFY_API_URL= ${COMFY_API_URL} "
ghcr.io/realazthat/comfy-catapult:v3.0.0
execute --workflow-path ./test_data/sdxlturbo_example_api.json
Si desea crear la imagen usted mismo, puede utilizar el Dockerfile en el repositorio.
# Build the docker image.
docker build -t my-comfy-catapult-image .
# Print usage.
docker run --rm --tty my-comfy-catapult-image --help
# /data in the docker image is the working directory, so paths are simpler.
docker run --rm --tty
-v " ${PWD} :/data "
-e " COMFY_API_URL= ${COMFY_API_URL} "
my-comfy-catapult-image
execute --workflow-path ./test_data/sdxlturbo_example_api.json
Para ejecutar pre.sh
(entorno similar a Linux).
Desde ./.github/dependencies.yml, que se utiliza para que GH Action realice una nueva instalación de todo:
bash : scripts.
findutils : scripts.
grep : tests.
xxd : tests.
git : scripts, tests.
xxhash : scripts (changeguard).
rsync : out-of-directory test.
jq : dependency for [yq](https://github.com/kislyuk/yq), which is used to generate
the README; the README generator needs to use `tomlq` (which is a part of `yq`)
to query `pyproject.toml`.
Requiere pyenv
, o una versión exacta de python como en ./.python-version.
jq
, (instalación) requerida para yq, que a su vez es necesaria para nuestra generación ./README.md
, que usa tomlq
(del paquete yq) para incluir cadenas de versión de ./pyproject.toml.
actuar (para ejecutar la Acción GH localmente):
Generar animación:
ventana acoplable (para construir la imagen de la ventana acoplable).
develop
.git add path/to/file.py
.bash scripts/pre.sh
, esto formateará, eliminará y probará el código.git status
verifica si algo cambió (generado ./README.md
por ejemplo), si es así, git add
los cambios y vuelve al paso anterior.git commit -m "..."
.develop
(o presione para desarrollar si tiene los derechos). Estas instrucciones son para los mantenedores del proyecto.
develop
: ejecute bash ./scripts/pre.sh
para asegurarse de que todo esté en orden.develop
: actualice la versión en ./pyproject.toml, siguiendo los principios de control de versiones semántico. Modifique también last_release
y last_stable_release
en la tabla [tool.comfy_catapult-project-metadata]
según corresponda.develop
: confirme estos cambios con un mensaje como "Preparar la versión XYZ". (Consulte la sección de contribuciones más arriba).master
: fusiona la rama develop
con la rama master
: git checkout master && git merge develop --no-ff
.master
: etiquetar la versión: cree una etiqueta git para la versión con git tag -a vX.YZ -m "Version XYZ"
.bash ./scripts/utilities/deploy-to-pypi.sh
.git push
y git push --tags
.git checkout develop && git merge master
La opción --no-ff
agrega una confirmación a la rama master para la fusión, así que vuelve a bifurcar la rama de desarrollo desde la rama master.git push origin develop
Envía la rama de desarrollo a GitHub.