Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+venv
+flagged
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

README.md

@@ -1,12 +1,60 @@
 ---
-title: Comfyui Deploy Gradio
-emoji: ⚡
-colorFrom: gray
-colorTo: green
+title: comfyui-deploy-gradio
+app_file: main.py
 sdk: gradio
 sdk_version: 4.41.0
-app_file: app.py
-pinned: false
 ---
+# ComfyDeploy Gradio Interface
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This project provides a Gradio interface for interacting with ComfyDeploy, allowing users to dynamically generate UI components based on deployment input definitions and submit jobs to ComfyDeploy.
+
+![ComfyDeploy Gradio Interface](assets/cover.png)
+
+## Features
+
+- Dynamic UI generation based on ComfyDeploy input definitions
+- Support for various input types (text, image, number, checkbox, etc.)
+- Asynchronous job submission to ComfyDeploy
+- Real-time progress tracking
+- Display of output images and text
+
+## Installation
+
+1. Clone this repository
+2. Install the required dependencies:
+
+```bash
+pip install comfydeploy gradio pillow requests python-dotenv
+```
+
+3. Create a `.env` file in the project root with the following content:
+
+```
+API_KEY=your_comfydeploy_api_key
+DEPLOYMENT_ID=your_deployment_id
+```
+
+## Usage
+
+Run the main script:
+
+```bash
+python main.py
+```
+
+This will launch a Gradio interface in your default web browser. The interface will dynamically generate input components based on your ComfyDeploy deployment configuration. You can then input values and submit jobs to ComfyDeploy.
+
+## How it works
+
+1. The script fetches input definitions from ComfyDeploy.
+2. It dynamically generates Gradio components based on these definitions.
+3. When the user submits inputs, it sends a job to ComfyDeploy.
+4. The script then polls for job completion and displays the results (images and text).
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

main.py

@@ -0,0 +1,127 @@
+from comfydeploy import ComfyDeploy
+import asyncio
+import os
+import gradio as gr
+from PIL import Image
+import requests
+import dotenv
+from io import BytesIO
+# from gradio_imageslider import ImageSlider
+
+dotenv.load_dotenv()
+
+client = ComfyDeploy(bearer_auth=os.environ['API_KEY'])
+deployment_id = os.environ['DEPLOYMENT_ID']
+
+def get_gradio_component(class_type):
+    component_map = {
+        'ComfyUIDeployExternalText': gr.Textbox,
+        'ComfyUIDeployExternalImage': gr.Image,
+        'ComfyUIDeployExternalImageAlpha': gr.Image,
+        'ComfyUIDeployExternalNumber': gr.Number,
+        'ComfyUIDeployExternalNumberInt': gr.Number,
+        'ComfyUIDeployExternalLora': gr.Textbox,
+        'ComfyUIDeployExternalCheckpoint': gr.Textbox,
+        'ComfyDeployWebscoketImageInput': gr.Image,
+        'ComfyUIDeployExternalImageBatch': gr.File,
+        'ComfyUIDeployExternalVideo': gr.Video,
+        'ComfyUIDeployExternalBoolean': gr.Checkbox,
+        'ComfyUIDeployExternalNumberSlider': gr.Slider,
+    }
+    return component_map.get(class_type, gr.Textbox)  # Default to Textbox if not found
+
+# Function to update inputs
+def get_inputs():
+    res = client.deployment.get_input_definition(id=deployment_id)
+    input_definitions = res.response_bodies
+    gradio_inputs = []
+    for input_def in input_definitions:
+        component_class = get_gradio_component(input_def.class_type)
+        
+        kwargs = {
+            "label": input_def.input_id,
+            "value": input_def.default_value
+        }
+        
+        print(kwargs)
+        
+        if input_def.class_type == 'ComfyUIDeployExternalNumberSlider':
+            kwargs.update({
+                "minimum": input_def.min_value,
+                "maximum": input_def.max_value
+            })
+        elif input_def.class_type in ['ComfyUIDeployExternalImage', 'ComfyUIDeployExternalImageAlpha', 'ComfyDeployWebscoketImageInput']:
+            kwargs["type"] = "filepath"
+        elif input_def.class_type == 'ComfyUIDeployExternalImageBatch':
+            kwargs["file_count"] = "multiple"
+        elif input_def.class_type == 'ComfyUIDeployExternalNumberInt':
+            kwargs["precision"] = 0
+            
+        # print(kwargs)
+        
+        gradio_inputs.append(component_class(**kwargs))
+        
+    return gradio_inputs, input_definitions
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column(scale=1):
+            @gr.render()
+            def update_inputs():
+                inputs, input_definitions = get_inputs()
+                submit_button = gr.Button("Submit")
+                
+                async def main(*args):
+                    inputs = {input_def.input_id: arg for input_def, arg in zip(input_definitions, args)}
+                    
+                    for key, value in inputs.items():
+                        if isinstance(value, list) and all(isinstance(url, str) for url in value):
+                            inputs[key] = [requests.get(url).content for url in value]
+                        elif isinstance(value, str) and value.startswith('http'):
+                            inputs[key] = requests.get(value).content
+
+                    res = await client.run.create_async(
+                        request={
+                            "deployment_id": deployment_id,
+                            "inputs": inputs
+                        })
+
+                    images = []
+                    text = ""
+                    outputs = [
+                        images,
+                        text
+                    ]
+                    while True:
+                        if res.object is not None:
+                            res2 = await client.run.get_async(run_id=res.object.run_id)
+                            print("checking ", res2.object.progress, res2.object.live_status)
+
+                            if res2.object is not None and res2.object.status == "success":
+                                # print(res2)
+                                for output in res2.object.outputs:
+                                    print(output.data.images)
+                                    if output.data.images:
+                                        urls = [image.url for image in output.data.images]
+                                        for url in urls:
+                                            response = requests.get(url)
+                                            img = Image.open(BytesIO(response.content))
+                                            outputs[0].append(img)
+                                    elif output.data.text:
+                                        print(output.data.text)
+                                        outputs[1] += "\n\n" + "\n".join(output.data.text)
+                                break
+                        await asyncio.sleep(2)
+
+                    return outputs
+                
+                submit_button.click(fn=main, inputs=inputs, outputs=output_components)
+        
+        with gr.Column(scale=1):
+            output_components = [
+                gr.Gallery(),
+                gr.Textbox(label="Text Output")
+            ]
+            
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1,3 @@
+comfydeploy==0.3.4
+gradio==4.41.0
+gradio_imageslider