Upload folder via script

.github/workflows/publish-hf.yml

@@ -1,4 +1,34 @@
 name: Publish to HuggingFace
+
 on:
+  workflow_dispatch:
+  push:
+    tags:
+      - "*"
 
 jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Sync (release deps)
+        run: uv sync --frozen --group release
+
+      - name: Publish
+        env:
+          HF_REPO_ID: ${{ vars.HF_REPO_ID }}
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          set -euo pipefail
+          make publish HF_REPO_ID="${HF_REPO_ID}"

Dockerfile

@@ -26,7 +26,9 @@ RUN uv sync --frozen --no-dev
 # Now copy the rest of the project
 COPY . .
 
-ENV PORT=7860
+ENV VELAI_HOST="0.0.0.0"
+ENV VELAI_PORT=7860
+
 EXPOSE 7860
 
 # Default command to start your app

Makefile

@@ -1,5 +1,7 @@
 .PHONY: fmt fmt-check lint autoformat build publish
 
+default: build
+
 # Code Style
 fmt:
 	uv run --group lint ruff format .

velai/async_utils.py

@@ -1,8 +1,73 @@
+import asyncio
+import functools
+import inspect
+from concurrent.futures import Executor
 from dataclasses import dataclass, field
-from typing import Awaitable, Callable, Any
+from typing import Any, Awaitable, Callable, Concatenate, Generic, Optional, ParamSpec, TypeVar
 
 from nicegui import ui
 
+P = ParamSpec("P")
+R = TypeVar("R")
+T = TypeVar("T")
+
+
+def async_wrap(fn: Callable[P, R], *, executor: Optional[Executor] = None) -> Callable[P, Awaitable[R]]:
+    @functools.wraps(fn)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        if executor is None:
+            return await asyncio.to_thread(fn, *args, **kwargs)
+        loop = asyncio.get_running_loop()
+        call = functools.partial(fn, *args, **kwargs)
+        return await loop.run_in_executor(executor, call)
+
+    wrapper.__isabstractmethod__ = False
+    return wrapper
+
+
+class AsyncMethod(Generic[T, P, R]):
+    __isabstractmethod__ = False
+
+    def __init__(
+        self, sync_method: Callable[Concatenate[T, P], R], *, executor: Optional[Executor] = None, cache: bool = True
+    ):
+        self._sync_name = sync_method.__name__
+        self._executor = executor
+        self._cache = cache
+        self._attr_name: Optional[str] = None
+
+    def __set_name__(self, owner, name: str) -> None:
+        self._attr_name = name
+
+    def __get__(self, obj: Optional[T], objtype=None) -> Callable[P, Awaitable[R]]:
+        if obj is None:
+            return self
+
+        if self._cache and self._attr_name is not None:
+            cached = obj.__dict__.get(self._attr_name)
+            if cached is not None:
+                return cached
+
+        sync = getattr(obj, self._sync_name)
+
+        async_fn = async_wrap(sync, executor=self._executor)
+        async_fn.__signature__ = inspect.signature(sync)
+        async_fn.__isabstractmethod__ = False
+
+        if self._cache and self._attr_name is not None:
+            obj.__dict__[self._attr_name] = async_fn
+
+        return async_fn
+
+
+def async_method_wrapper(
+    sync_method: Callable[Concatenate[T, P], R],
+    *,
+    executor: Optional[Executor] = None,
+    cache: bool = True,
+) -> AsyncMethod[T, P, R]:
+    return AsyncMethod(sync_method, executor=executor, cache=cache)
+
 
 @dataclass
 class AsyncDirtyTimer:

velai/nodes/base_execution_node.py

@@ -40,7 +40,7 @@ class ExecutionNode(BaseNode[T_EXECUTION_DATA], Generic[T_EXECUTION_DATA], ABC):
     async def on_queue_for_processing(self):
         self.data.error_message = ""
         self.data.progress_value = None
-        self.data.progress_message = "Waiting in queue"
+        self.data.progress_message = None
 
     async def process(self) -> None:
         # early exit if already processed
@@ -86,7 +86,7 @@ class ExecutionNodeRenderable(BaseNodeRenderable[T_EXECUTION_NODE], Generic[T_EX
         self.action_registry.register("reset_node", self._on_reset_node_action)
         self.action_registry.register("download_data", self._on_download_data_action)
 
-    async def _on_reset_node_action(self, args: NodeActionArguments) -> NodeActionResult:
+    async def _on_reset_node_action(self, args: NodeActionArguments) -> NodeActionResult | None:
         # Confirm with the user before resetting
         with ui.dialog() as dialog, ui.card():
             ui.label("Are you sure to reset the node?")
@@ -95,7 +95,7 @@ class ExecutionNodeRenderable(BaseNodeRenderable[T_EXECUTION_NODE], Generic[T_EX
                 ui.button("No", on_click=lambda: dialog.submit("No"))
         result = await dialog
         if result == "No":
-            return NodeActionResult.discard()
+            return
 
         # Reset the outputs of a node
         args.node.reset_outputs()
@@ -103,20 +103,20 @@ class ExecutionNodeRenderable(BaseNodeRenderable[T_EXECUTION_NODE], Generic[T_EX
         ui.notify("Node has been reset!", type="positive")
         return NodeActionResult.update()
 
-    async def _on_download_data_action(self, args: NodeActionArguments) -> NodeActionResult:
+    async def _on_download_data_action(self, args: NodeActionArguments) -> NodeActionResult | None:
         if isinstance(args.node, ExecutionNode):
             data = await args.node.get_download_data()
 
             if data is None:
                 ui.notify("Nothing to download!", type="warning")
-                return NodeActionResult.discard()
+                return
 
             ui.notify("Download started...", type="positive")
             if isinstance(data, str):
                 ui.navigate.to(data, new_tab=True)
             else:
                 ui.download(data.src, data.filename, data.mime_type)
-        return NodeActionResult.discard()
+        return
 
     def get_header_buttons(self, node: T_EXECUTION_NODE) -> list[dict[str, Any]]:
         buttons = super().get_header_buttons(node)

velai/nodes/base_node_renderable.py

@@ -1,10 +1,10 @@
 from abc import ABC
-from typing import Generic, TypeVar, Any
+from typing import Any, Generic, TypeVar
 
-from velai.nodes.actions.node_action_registry import NodeActionRegistry, NodeActionNotFoundError
+from velai.nodes.actions.node_action_registry import NodeActionNotFoundError, NodeActionRegistry
 from velai.nodes.actions.node_actions_models import NodeActionArguments, NodeActionResult
 from velai.nodes.base_node import BaseNode, logger
-from velai.nodes.vue_nodes import VueNodeRenderable, VueNodeData
+from velai.nodes.vue_nodes import VueNodeData, VueNodeRenderable
 
 T_BASE_NODE = TypeVar("T_BASE_NODE", bound=BaseNode)
 
@@ -14,12 +14,11 @@ class BaseNodeRenderable(VueNodeRenderable[T_BASE_NODE], Generic[T_BASE_NODE], A
         super().__init__()
         self.action_registry = NodeActionRegistry()
 
-    async def run_custom_action(self, args: NodeActionArguments) -> NodeActionResult:
+    async def run_custom_action(self, args: NodeActionArguments) -> NodeActionResult | None:
         try:
             return await self.action_registry.run_action(args)
         except NodeActionNotFoundError:
             logger.exception()
-            return NodeActionResult()
 
     # todo: create actual renderable fields that correspond to the vue components
     def get_header_buttons(self, node: T_BASE_NODE) -> list[dict[str, Any]]:

velai/nodes/image_data.py

@@ -2,18 +2,18 @@ from __future__ import annotations
 
 from typing import Any
 
+from velai.data_types import ImageType
 from velai.dataflow.enums import NodeKind, PortDirection
 from velai.dataflow.nodes import NodeType
 from velai.dataflow.ports import PortSchema
-from velai.data_types import ImageType
 from velai.nodes.base_node import BaseNode, BaseNodeData
-from velai.nodes.base_node_renderable import BaseNodeRenderable, T_BASE_NODE
+from velai.nodes.base_node_renderable import T_BASE_NODE, BaseNodeRenderable
 
 ImageDataNodeType = NodeType(
     kind=NodeKind.IMAGE_DATA,
     display_name="Image",
     inputs=[],
-    outputs=[PortSchema(name="image", dtype=ImageType, direction=PortDirection.OUTPUT)],
+    outputs=[PortSchema(name="image", dtype=ImageType, direction=PortDirection.OUTPUT, tooltip="Image")],
 )
 
 

velai/nodes/image_to_mesh.py

@@ -6,21 +6,22 @@ from functools import partial
 
 from PIL.Image import Image
 
-from velai.dataflow.enums import PortDirection, NodeKind, ConnectMultiplicity
+from velai.data_types import ImageType, MeshType, TextType
+from velai.dataflow.enums import ConnectMultiplicity, NodeKind, PortDirection
 from velai.dataflow.nodes import NodeType
 from velai.dataflow.ports import PortSchema
-from velai.services.mesh import MeshGenerator, MeshGenerationResult
+from velai.services.mesh import MeshGenerationResult, MeshGenerator
 from velai.services.registry import get_registry
 from velai.services.services import TaskType
-from velai.data_types import ImageType, TextType, MeshType
+
+from ..storage import storage_endpoint
 from .base_execution_node import (
-    ExecutionNode,
-    ExecutionNodeRenderable,
     T_EXECUTION_NODE,
     DownloadData,
+    ExecutionNode,
     ExecutionNodeData,
+    ExecutionNodeRenderable,
 )
-from ..storage import storage_endpoint
 
 DEFAULT_MESH_MODEL_SERVICE_ID = os.getenv("DEFAULT_MESH_MODEL_SERVICE_ID", "fal_ai_mesh_sam3d")
 
@@ -34,6 +35,7 @@ ImageToMeshNodeType = NodeType(
             direction=PortDirection.INPUT,
             multiplicity=ConnectMultiplicity.SINGLE,
             capacity=1,
+            tooltip="Prompt / Mask",
         ),
         PortSchema(
             name="image",
@@ -41,6 +43,7 @@ ImageToMeshNodeType = NodeType(
             direction=PortDirection.INPUT,
             multiplicity=ConnectMultiplicity.SINGLE,
             capacity=1,
+            tooltip="Image",
         ),
     ],
     outputs=[

velai/nodes/text_data.py

@@ -1,22 +1,30 @@
 from __future__ import annotations
 
 import logging
+import os
+import typing
 from typing import Any
 
+from velai.data_types import TextType
 from velai.dataflow.enums import NodeKind, PortDirection
 from velai.dataflow.nodes import NodeType
 from velai.dataflow.ports import PortSchema
-from velai.data_types import TextType
+from velai.nodes.actions.node_actions_models import NodeActionArguments, NodeActionResult
 from velai.nodes.base_node import BaseNode, BaseNodeData
-from velai.nodes.base_node_renderable import BaseNodeRenderable, T_BASE_NODE
+from velai.nodes.base_node_renderable import T_BASE_NODE, BaseNodeRenderable
+from velai.services.registry import get_registry
+from velai.services.services import TaskType
+from velai.services.text.TextGenerator import TextGenerator
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_TEXT_MODEL_SERVICE_ID = os.getenv("DEFAULT_TEXT_MODEL_SERVICE_ID", "fal_ai_gemini_flash_text")
+
 TextDataNodeType = NodeType(
     kind=NodeKind.TEXT_DATA,
     display_name="Text",
     inputs=[],
-    outputs=[PortSchema(name="text", dtype=TextType, direction=PortDirection.OUTPUT)],
+    outputs=[PortSchema(name="text", dtype=TextType, direction=PortDirection.OUTPUT, tooltip="Text")],
 )
 
 
@@ -30,6 +38,10 @@ class TextDataNode(BaseNode[BaseNodeData]):
 
 
 class TextDataNodeRenderable(BaseNodeRenderable[TextDataNode]):
+    def __init__(self):
+        super().__init__()
+        self.action_registry.register("enhance_text", self._on_enhance_text_action)
+
     def get_fields(self, node: T_BASE_NODE) -> list[dict[str, Any]]:
         return [
             *super().get_fields(node),
@@ -40,3 +52,36 @@ class TextDataNodeRenderable(BaseNodeRenderable[TextDataNode]):
                 "placeholder": "Enter text...",
             },
         ]
+
+    def get_header_buttons(self, node: T_BASE_NODE) -> list[dict[str, Any]]:
+        buttons = super().get_header_buttons(node)
+
+        buttons.append(
+            {
+                "name": "enhance",
+                "icon": "spellcheck",
+                "tooltip": "Enhance",
+                "action": "enhance_text",
+                "requireContent": False,
+                "disableWhileProcessing": False,
+            }
+        )
+
+        return buttons
+
+    async def _on_enhance_text_action(self, args: NodeActionArguments) -> NodeActionResult:
+        text_output = args.node.outputs["text"]
+
+        # run model
+        registry = get_registry()
+        text_service = typing.cast(TextGenerator, registry.create(TaskType.TEXT, DEFAULT_TEXT_MODEL_SERVICE_ID))
+
+        # todo: improve prompt
+        result = await text_service.generate_async(
+            f"Please enhance this image prompt for genai image generation "
+            f"and only return the resulting prompt (no enclosing formatting): "
+            f"```{text_output.value}```"
+        )
+
+        text_output.value = result.text
+        return NodeActionResult.update()

velai/nodes/text_to_image.py

@@ -43,6 +43,7 @@ TextToImageNodeType = NodeType(
             direction=PortDirection.INPUT,
             multiplicity=ConnectMultiplicity.MULTIPLE,
             capacity=3,
+            tooltip="Prompt",
         ),
         PortSchema(
             name="image1",
@@ -50,6 +51,7 @@ TextToImageNodeType = NodeType(
             direction=PortDirection.INPUT,
             multiplicity=ConnectMultiplicity.SINGLE,
             capacity=1,
+            tooltip="Image 1",
         ),
         PortSchema(
             name="image2",
@@ -57,6 +59,7 @@ TextToImageNodeType = NodeType(
             direction=PortDirection.INPUT,
             multiplicity=ConnectMultiplicity.SINGLE,
             capacity=1,
+            tooltip="Image 2",
         ),
         PortSchema(
             name="image3",
@@ -64,6 +67,7 @@ TextToImageNodeType = NodeType(
             direction=PortDirection.INPUT,
             multiplicity=ConnectMultiplicity.SINGLE,
             capacity=1,
+            tooltip="Image 3",
         ),
     ],
     outputs=[PortSchema(name="image", dtype=ImageType, direction=PortDirection.OUTPUT)],

velai/services/image/ImageGenerator.py

@@ -3,6 +3,7 @@ from typing import Any, Sequence
 
 from PIL import Image
 
+from velai.async_utils import async_method_wrapper
 from velai.services.image.ImageGenerationResult import ImageGenerationResult
 from velai.services.progress import ProgressCallback
 from velai.services.services import GenerationService, TaskType
@@ -26,3 +27,5 @@ class ImageGenerator(GenerationService, ABC):
         """Generate images from a prompt and optional images."""
 
         raise NotImplementedError
+
+    generate_async = async_method_wrapper(generate)

velai/services/mesh/DummyMeshGenerator.py

@@ -2,14 +2,14 @@ from __future__ import annotations
 
 import random
 import time
-from typing import Sequence, Any
+from typing import Any, Sequence
 
 from PIL import Image
 
+from ..progress import ProgressCallback, call_progress
+from ..registry import register_service
 from .MeshGenerationResult import MeshGenerationResult
 from .MeshGenerator import MeshGenerator
-from ..progress import ProgressCallback
-from ..registry import register_service
 
 KHRONOS_GROUP_URL = "https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/master"
 
@@ -53,7 +53,9 @@ class DummyMeshGenerator(MeshGenerator):
         jitter = random.randint(-64, 64)
         mesh_url += f"?{jitter}"
 
-        time.sleep(1.0)
+        for i in range(1, 9):
+            call_progress(progress, i * 0.1, "Generating mesh")
+            time.sleep(0.1)
 
         return MeshGenerationResult(
             provider="dummy",

velai/services/mesh/MeshGenerator.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Sequence, Any
+from typing import Any, Sequence
 
 from PIL import Image
 
-from .MeshGenerationResult import MeshGenerationResult
+from ...async_utils import async_method_wrapper
 from ..progress import ProgressCallback
-from ..services import TaskType, GenerationService
+from ..services import GenerationService, TaskType
+from .MeshGenerationResult import MeshGenerationResult
 
 
 class MeshGenerator(GenerationService, ABC):
@@ -24,3 +25,5 @@ class MeshGenerator(GenerationService, ABC):
         **kwargs: Any,
     ) -> MeshGenerationResult:
         raise NotImplementedError
+
+    generate_async = async_method_wrapper(generate)

velai/services/text/FalAITextGenerator.py

@@ -122,3 +122,11 @@ class FalAITextGenerator(TextGenerator):
             text=text_output,
             raw_response=response,
         )
+
+
+@register_service
+class FalAIGeminiFlashTextGenerator(FalAITextGenerator):
+    service_id = "fal_ai_gemini_flash_text"
+
+    def __init__(self, model_name: str | None = None):
+        super().__init__(model_name=model_name, extra_arguments={"model": "google/gemini-2.5-flash"})

velai/services/text/TextGenerator.py

@@ -3,8 +3,9 @@ from typing import Sequence
 
 from PIL import Image
 
+from velai.async_utils import async_method_wrapper
 from velai.services.progress import ProgressCallback
-from velai.services.services import TaskType, GenerationService
+from velai.services.services import GenerationService, TaskType
 from velai.services.text.TextGenerationResult import TextGenerationResult
 
 
@@ -23,3 +24,5 @@ class TextGenerator(GenerationService, ABC):
     ) -> TextGenerationResult:
         """Generate text from a prompt and optional images."""
         raise NotImplementedError
+
+    generate_async = async_method_wrapper(generate)

velai/session.py

@@ -23,7 +23,7 @@ from velai.ui.vueflow_canvas import VueFlowCanvas
 from . import app_context
 from .async_utils import AsyncDirtyTimer
 from .controller import GraphController
-from .nodes.actions.node_actions_models import NodeActionArguments
+from .nodes.actions.node_actions_models import NodeActionArguments, NodeActionResult
 from .nodes.base_node import BaseNode
 from .nodes.base_node_renderable import BaseNodeRenderable
 from .nodes.image_to_mesh import ImageToMeshNode, ImageToMeshNodeRenderable, ImageToMeshNodeType
@@ -480,14 +480,19 @@ class GraphSession:
             if not isinstance(node_renderable, BaseNodeRenderable):
                 return
 
+            await canvas.set_node_processing(node_id, True)
             result = await node_renderable.run_custom_action(NodeActionArguments(action, node))
 
+            if result is None:
+                result = NodeActionResult.discard()
+
             if result.requires_ui_sync:
                 await self.runtime.sync_node_to_ui(node)
 
             if result.requires_data_save and self.autosaver is not None:
                 self.autosaver.mark_dirty()
 
+            await canvas.set_node_processing(node_id, False)
             return
 
         elif event_type == "execute_node":

velai/ui/vueflow_canvas.vue

@@ -1025,7 +1025,7 @@ export default {
                   :indeterminate="typeof data.values.progress_value !== 'number'"
                   size="28px"
                   rounded
-                  show-value
+                  :show-value="typeof data.values.progress_value === 'number'"
               />
               <div class="vf-inner-loading-text">
                   <span v-if="data.values.progress_message">