Upload folder via script

velai/services/image/FalAIImageGenerator.py

@@ -266,7 +266,7 @@ class FalAIKrea2TurboGenerator(FalAIImageGenerator):
 
 @register_service(ImageGenerator)
 class FalAINanoBananaGenerator(FalAITextAndEditImageGenerator):
-    """fal-ai/nano-banana text and edit combination."""
+    """fal-ai/nano-banana-2 text and edit combination (Gemini 3.1 Flash Image)."""
 
     @classmethod
     def get_service_id(cls) -> str:
@@ -274,24 +274,24 @@ class FalAINanoBananaGenerator(FalAITextAndEditImageGenerator):
 
     def __init__(self, api_key: str | None = None) -> None:
         super().__init__(
-            service_model_name="fal-ai/nano-banana",
+            service_model_name="fal-ai/nano-banana-2",
             api_key=api_key,
-            text_model="fal-ai/nano-banana",
-            edit_model="fal-ai/nano-banana/edit",
+            text_model="fal-ai/nano-banana-2",
+            edit_model="fal-ai/nano-banana-2/edit",
             image_argument="image_urls",
         )
 
     @classmethod
     def get_name(cls) -> str:
-        return "Nano Banana"
+        return "Nano Banana 2"
 
     @classmethod
     def default_model_name(cls) -> str:
-        return "fal-ai/nano-banana"
+        return "fal-ai/nano-banana-2"
 
     def _calculate_cost(self, model: str, input_data: ImageGenerationInput, response: dict[str, Any]) -> float | None:
-        # text and image to image price is the same
-        return 0.039
+        # 1K list price on fal; 2K/4K are higher.
+        return 0.08
 
 
 class FalAIReveGenerator(FalAIImageGenerator):

velai/session.py

@@ -542,7 +542,11 @@ class GraphSession:
     def duplicate_nodes(
         self, source_node_ids: list[str], position: dict[str, Any] | None = None
     ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
-        """Duplicate nodes and recreate connections within the copied selection."""
+        """Duplicate nodes and recreate their connections.
+
+        Keeps edges between copied nodes, and also rewires edges that linked a
+        copied node to an uncopied neighbor onto the duplicate.
+        """
         source_ids = {node_id for node_id in source_node_ids if node_id}
         sources = [self.graph.nodes[node_id] for node_id in source_node_ids if node_id in self.graph.nodes]
         if not sources:
@@ -592,16 +596,23 @@ class GraphSession:
             vue_nodes.append(self.renderer.to_vue_node(dup_node))
 
         vue_edges: list[dict[str, Any]] = []
-        for conn in self.graph.connections:
+        # Snapshot: we append while iterating.
+        for conn in list(self.graph.connections):
             src_id = conn.start_node.node_id
             tgt_id = conn.end_node.node_id
-            if src_id not in source_ids or tgt_id not in source_ids:
+            if src_id not in source_ids and tgt_id not in source_ids:
                 continue
-            if src_id not in id_map or tgt_id not in id_map:
+
+            new_src_id = id_map.get(src_id, src_id)
+            new_tgt_id = id_map.get(tgt_id, tgt_id)
+            # Need at least one remapped endpoint (a duplicated node).
+            if new_src_id == src_id and new_tgt_id == tgt_id:
                 continue
 
-            new_start = self.graph.nodes[id_map[src_id]]
-            new_end = self.graph.nodes[id_map[tgt_id]]
+            new_start = self.graph.nodes.get(new_src_id)
+            new_end = self.graph.nodes.get(new_tgt_id)
+            if new_start is None or new_end is None:
+                continue
 
             start_port = new_start.outputs.get(conn.start_port.name) if new_start.outputs else None
             if start_port is None and new_start.inputs:

velai/ui/training.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import os
+import re
 from typing import TYPE_CHECKING, List, Optional
 
 import fal_client
@@ -19,6 +20,15 @@ KREA_TRAINER_MODEL = "fal-ai/krea-2-trainer"
 MAX_ZIP_BYTES = MAX_DATASET_ZIP_MB * 1024 * 1024
 
 
+def lora_download_filename(name: str) -> str:
+    """Build a safe download filename from the user-facing LoRA name."""
+    base = (name or "lora").strip() or "lora"
+    base = re.sub(r"[^\w.\- ]+", "_", base).strip(" ._") or "lora"
+    if not base.lower().endswith(".safetensors"):
+        base = f"{base}.safetensors"
+    return base
+
+
 class TrainingDialog:
     def __init__(self, on_library_changed=None, app_ctx: "AppContext | None" = None) -> None:
         self.zip_url: Optional[str] = None
@@ -161,7 +171,7 @@ class TrainingDialog:
                         with ui.row().classes("gap-1"):
                             ui.button(
                                 icon="download",
-                                on_click=lambda e=entry: ui.download(e.url, f"{e.name}.safetensors"),
+                                on_click=lambda e=entry: asyncio.create_task(self._download_entry(e)),
                             ).props("flat dense")
                             ui.button(
                                 icon="delete",
@@ -174,6 +184,16 @@ class TrainingDialog:
             if asyncio.iscoroutine(result):
                 asyncio.create_task(result)
 
+    async def _download_entry(self, entry: LoraEntry) -> None:
+        filename = lora_download_filename(entry.name)
+        try:
+            blob = await storage_endpoint.get_blob_by_url(entry.url)
+            data = await blob.read_bytes()
+            ui.download(data, filename, "application/octet-stream")
+        except Exception:
+            src = entry.fal_url if entry.fal_url.startswith("http") else entry.url
+            ui.download(src, filename, "application/octet-stream")
+
     def _delete_entry(self, entry: LoraEntry) -> None:
         delete_lora(self._user_storage(), entry.id)
         ui.notify(f"Removed {entry.name}", type="info")
@@ -337,13 +357,13 @@ class TrainingDialog:
         if not lora_remote:
             raise RuntimeError("Trainer did not return LoRA weights")
 
-        original_name = lora_file.get("file_name") or "krea_lora.safetensors"
+        name = (self.lora_name.value or "My LoRA").strip()
+        filename = lora_download_filename(name)
         stored_lora = await storage_endpoint.download_and_store_url(
             lora_remote,
-            original_name=original_name,
+            original_name=filename,
             mime_type="application/octet-stream",
         )
-        name = (self.lora_name.value or "My LoRA").strip()
         add_lora(
             self._user_storage(),
             name=name,
@@ -354,7 +374,9 @@ class TrainingDialog:
         )
 
         self.result_container.set_visibility(True)
-        self.download_lora_btn.on_click(lambda: ui.download(stored_lora, f"{name}.safetensors"))
+        self.download_lora_btn.on_click(
+            lambda: asyncio.create_task(self._download_stored_lora(stored_lora, filename))
+        )
         if config_remote:
             self.download_config_btn.on_click(
                 lambda: ui.download(config_remote, config_file.get("file_name") or "config.json")
@@ -363,6 +385,14 @@ class TrainingDialog:
         else:
             self.download_config_btn.disable()
 
+    async def _download_stored_lora(self, stored_url: str, filename: str) -> None:
+        try:
+            blob = await storage_endpoint.get_blob_by_url(stored_url)
+            data = await blob.read_bytes()
+            ui.download(data, filename, "application/octet-stream")
+        except Exception:
+            ui.download(stored_url, filename, "application/octet-stream")
+
     def open(self) -> None:
         self.refresh_library()
         self.dialog.open()