catapulte confortable

?Accueil • ?Fonctionnalités • ?Installation • ?Utilisation • Documentation • ?API

✅Exigences • CLI • ?Docker • ?Limitations

Bibliothèque Python pour planifier par programme les flux de travail ComfyUI via l'API ComfyUI

---

Bifurquer	Statut de construction	S'engage depuis	Dernier commit
Maître
Développer

 ComfyUI API Endpoint <| <=  Comfy Catapult <=> HTTP Server <| <=  Public users
                     <|                                    <|
                     <|         Your python program        <| Your Webui/JS frontend
                     <|                                    <|
                     <|           Your workflows           <|
                     <|          Your HTTP server          <|

Qu'est-ce que c'est?

Comfy Catapult est une bibliothèque permettant de planifier et d'exécuter des flux de travail ComfyUI à partir d'un programme Python, via le point de terminaison API existant. ComfyUI fonctionne généralement en hébergeant ce point de terminaison d'API pour son interface utilisateur.

Cela vous permet de créer plus facilement des flux de travail via l'interface utilisateur, puis de les utiliser à partir d'un programme.

? Caractéristiques

• Client API ComfyUI (interface, implémentation).
• Planificateur ComfyUI Workflow (interface, implémentation).
• Schéma Pydantic de l'API ComfyUI (./comfy_catapult/comfy_schema.py).
• Aides pour gérer le téléchargement et le téléchargement de fichiers vers/depuis ComfyUI.
• CLI simple pour exécuter des flux de travail.

? Installation

 # Inside your environment:

# From pypi:
pip install comfy_catapult

# From git:
pip install git+https://github.com/realazthat/[email protected]

? Usage

Projets connexes

Projet	Wrapper d'API ComfyUI	Externaliser le back-end	Distribuer l'exécution	Flux de travail d'enveloppement	Studio
CushyStudio	?	?	?	?	Oui
ComfyUI-Serving-Toolkit	X	?	?	Oui	?
ComfyUI_NetDist	X	?	Oui	?	?
Exemples de script ComfyUI	Oui	Non	Non	Non	Non
confortableui-python-api	?	?	?	Oui	?
confortui-déploiement	?	?	?	Oui	?
Extension ComfyUI vers Python	?	?	?	Oui	?
ComfyScript	?	?	?	Oui	?
hordelib	?	Oui	?	?	?
confortui-cloud	?	Oui	?	?	?
coureur_confortable	?	?	?	?	?
ComfyUI-ComfyRun	?	?	?	?	?

Documentation

Planification d'un travail

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]' ]:

Exemple d'utilisation :

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 )

Exporter des workflows au format API json

Dans l'interface Web ComfyUI :

1. Ouvrir les paramètres (boîte de vitesses dans le coin).
2. Activez la possibilité d'exporter au format API, Enable Dev mode Options .
3. Cliquez sur le nouvel élément de menu Save (API format) .

options execute :

Exemple d'utilisation :

python -m comfy_catapult.cli 
    execute --workflow-path ./test_data/sdxlturbo_example_api.json

✅ Exigences

• Python3.10+
• Serveur ComfyUI avec point de terminaison API activé.

Connu pour travailler sur

• WSL2/Windows11, Ubuntu 22.04.2 LTS : Python 3.8.0 .
• Ubuntu 20.04, Python 3.8.0, 3.9.0, 3.10.0, 3.11.0, 3.12.0 , testé dans le workflow GitHub Actions (./.github/workflows/build-and-test.yml).

? Image Docker

Les images Docker sont publiées sur ghcr.io/realazthat/comfy-catapult à chaque balise.

 # 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 vous souhaitez créer l'image vous-même, vous pouvez utiliser le Dockerfile dans le référentiel.

 # 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

? Limites

• L'interruption d'une tâche interrompra n'importe quelle tâche, et non la tâche spécifique interrompue. Voir #5.

FAIRE

• Les assistants doivent prendre en charge le stockage distant/cloud pour les répertoires d'entrée/sortie/modèle ComfyUI (actuellement, ne prend en charge que les chemins locaux).
• Estimateur ETA.
• Assurez-vous que le schéma peut analyser les formats même si le format ajoute de nouveaux champs.

Cotisations

Environnement de développement : de type Linux

• Pour exécuter pre.sh (environnement de type Linux).

  • À partir de ./.github/dependencies.yml, qui est utilisé par l'action GH pour effectuer une nouvelle installation de tout :

     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`.
    

  • Nécessite pyenv , ou une version exacte de python comme dans ./.python-version.

  • jq , (installation) requis pour yq, qui est lui-même requis pour notre génération ./README.md , qui utilise tomlq (du package yq) pour inclure les chaînes de version de ./pyproject.toml.

  • agir (pour exécuter l'action GH localement) :

    • Nécessite nodejs.
    • Nécessite Go.
    • docker.

  • Générer une animation :

    • docker

  • docker (pour créer l'image docker).

Processus de validation

1. (Facultatif) Forkez la branche develop .
2. Mettez en scène vos fichiers : git add path/to/file.py .
3. bash scripts/pre.sh , cela formatera, peluchera et testera le code.
4. git status vérifie si quelque chose a changé (généré ./README.md par exemple), si c'est le cas, git add les modifications et revient à l'étape précédente.
5. git commit -m "..." .
6. Faites un PR pour develop (ou poussez pour développer si vous avez les droits).

Processus de libération

Ces instructions sont destinées aux responsables du projet.

1. branche develop : exécutez bash ./scripts/pre.sh pour vous assurer que tout est en ordre.
2. branche develop : augmentez la version dans ./pyproject.toml, en suivant les principes de gestion des versions sémantiques. Modifiez également last_release et last_stable_release dans la table [tool.comfy_catapult-project-metadata] le cas échéant.
3. branche develop : validez ces modifications avec un message du type "Préparer la version XYZ". (Voir la section contributions ci-dessus).
4. branche master : fusionnez la branche develop dans la branche master : git checkout master && git merge develop --no-ff .
5. branche master : balisez la version : créez une balise git pour la version avec git tag -a vX.YZ -m "Version XYZ" .
6. Publier sur PyPI : publiez la version sur PyPI avec bash ./scripts/utilities/deploy-to-pypi.sh .
7. Push to GitHub : poussez le commit et les balises vers GitHub avec git push et git push --tags .
8. git checkout develop && git merge master L'option --no-ff ajoute un commit à la branche master pour la fusion, donc rebranchez la branche develop à partir de la branche master.
9. git push origin develop Poussez la branche de développement vers GitHub.