Upload app.py

app.py

@@ -1886,34 +1886,210 @@ with gr.Blocks(theme=args.theme, elem_id="main", fill_width=True, fill_height=Fa
         copy_prompt_btn.click(gradio_copy_prompt, inputs=[output_text], outputs=[prompt_gui], show_api=False)
         copy_prompt_btn_pony.click(gradio_copy_prompt, inputs=[output_text_pony], outputs=[prompt_gui], show_api=False)
 
-    # Stable programmatic endpoint
-    # --- minimal sync wrapper + stable API ---
-    from typing import Any, List, Tuple, Optional
-
-    def generate_minimal(
-        args: List[Any],
-        model_name: str=LOAD_DIFFUSERS_FORMAT_MODEL[0],
-        vae_model: Optional[str]=None,
-        task: str=TASK_MODEL_LIST[0],
-        controlnet_model: str=DIFFUSERS_CONTROLNET_MODEL[0]
-    ) -> Tuple[str, Optional[List[str]], Optional[str]]:
-        # Preload the requested model (drain loader yields so the model is ready)
-        for _ in sd_gen.load_new_model(model_name, vae_model, task, controlnet_model):
-            pass
-        # Run the existing streaming generator and collapse to the final triple
-        last_status, last_imgs, last_info = "START", None, None
-        for status, imgs, info in sd_gen_generate_pipeline(*args):
-            last_status, last_imgs, last_info = status, imgs, info
-        return last_status or "COMPLETE", last_imgs, last_info
-
-    gr.api(
-        generate_minimal,
-        api_name="generate_image",        # => POST /gradio_api/call/generate_image
-        api_description="Preload model then generate with full positional args. Returns final (status, images, info).",
-        show_api=True,                    # force listing on the API page
-        queue=True,                       # reuse app queue
-        concurrency_id="gpu"              # share GPU queue with other heavy events
-    )
+        from __future__ import annotations
+        from typing import Any, Dict, List, Optional, Tuple, Generator
+        import inspect
+        # 1) Single source of truth: define the full explicit signature once.
+        def _signature_src(
+            # 0..6
+            prompt: str,
+            negative_prompt: str = "",
+            num_images: int = 1,
+            num_inference_steps: int = 28,
+            guidance_scale: float = 7.0,
+            clip_skip: int = 0,
+            seed: int = -1,
+            # 7..20 LoRA
+            lora1: str = "", lora1_wt: float = 1.0,
+            lora2: str = "", lora2_wt: float = 1.0,
+            lora3: str = "", lora3_wt: float = 1.0,
+            lora4: str = "", lora4_wt: float = 1.0,
+            lora5: str = "", lora5_wt: float = 1.0,
+            lora6: str = "", lora6_wt: float = 1.0,
+            lora7: str = "", lora7_wt: float = 1.0,
+            # 21..23 sched
+            sampler: str = "Euler",
+            schedule_type: str = "Automatic",
+            schedule_prediction_type: str = "Automatic",
+            # 24..28 canvas/model/task
+            height: int = 1024,
+            width: int = 1024,
+            model_name: str = "votepurchase/animagine-xl-3.1",
+            vae_model: str = "None",
+            task: str = "txt2img",
+            # 29..35 control/style/mask
+            image_control_dict: Optional[dict] = None,
+            preprocessor_name: str = "Canny",
+            preprocess_resolution: int = 512,
+            image_resolution: int = 1024,
+            style_prompt: Optional[List[str]] = None,
+            style_json: Optional[dict] = None,
+            image_mask: Optional[Any] = None,
+            # 36..45 thresholds
+            strength: float = 0.55,
+            low_threshold: int = 100,
+            high_threshold: int = 200,
+            value_threshold: float = 0.1,
+            distance_threshold: float = 0.1,
+            recolor_gamma_correction: float = 1.0,
+            tile_blur_sigma: int = 9,
+            control_net_output_scaling: float = 1.0,
+            control_net_start_threshold: float = 0.0,
+            control_net_stop_threshold: float = 1.0,
+            # 46..51 TI/syntax/upscaler
+            textual_inversion: bool = False,
+            prompt_syntax: str = "Classic",
+            upscaler_model_path: Optional[str] = None,
+            upscaler_increases_size: float = 1.2,
+            upscaler_tile_size: int = 0,
+            upscaler_tile_overlap: int = 8,
+            # 52..60 hires
+            hires_steps: int = 30,
+            hires_denoising_strength: float = 0.55,
+            hires_sampler: str = "Use same sampler",
+            hires_prompt: str = "",
+            hires_negative_prompt: str = "",
+            adetailer_inpaint_only: bool = True,
+            adetailer_verbose: bool = False,
+            hires_schedule_type: str = "Use same schedule type",
+            hires_guidance_scale: float = -1.0,
+            # 61 controlnet model (loaderにも使用)
+            controlnet_model: str = "Automatic",
+            # 62..71 loop/ui/save/cache
+            loop_generation: bool = False,
+            leave_progress_bar: bool = False,
+            disable_progress_bar: bool = False,
+            image_previews: bool = True,
+            display_images: bool = True,
+            save_generated_images: bool = True,
+            filename_pattern: str = "model,seed",
+            image_storage_location: str = "./images/",
+            retain_compel_previous_load: bool = True,
+            retain_detailfix_model_previous_load: bool = True,
+            retain_hires_model_previous_load: bool = True,
+            # 72..78 t2i + perf
+            t2i_adapter_preprocessor: Optional[str] = None,
+            t2i_adapter_conditioning_scale: float = 0.55,
+            t2i_adapter_conditioning_factor: float = 1.0,
+            xformers_memory_efficient_attention: bool = True,
+            free_u: bool = False,
+            generator_in_cpu: bool = False,
+            # 79..101 ADetailer
+            adetailer_sampler: str = "Use same sampler",
+            adetailer_active_a: bool = False,
+            prompt_ad_a: str = "",
+            negative_prompt_ad_a: str = "",
+            strength_ad_a: float = 0.35,
+            face_detector_ad_a: bool = False,
+            person_detector_ad_a: bool = True,
+            hand_detector_ad_a: bool = False,
+            mask_dilation_a: int = 4,
+            mask_blur_a: int = 4,
+            mask_padding_a: int = 32,
+            adetailer_active_b: bool = False,
+            prompt_ad_b: str = "",
+            negative_prompt_ad_b: str = "",
+            strength_ad_b: float = 0.35,
+            face_detector_ad_b: bool = False,
+            person_detector_ad_b: bool = True,
+            hand_detector_ad_b: bool = False,
+            mask_dilation_b: int = 4,
+            mask_blur_b: int = 4,
+            mask_padding_b: int = 32,
+            # 102..117 cache/guidance/ip_adapter/pag/face_rest
+            cache_compel_texts: bool = True,
+            guidance_rescale: float = 0.0,
+            image_ip1_dict: Optional[dict] = None, mask_ip1: Optional[Any] = None,
+            model_ip1: str = "plus_face", mode_ip1: str = "original", scale_ip1: float = 0.7,
+            image_ip2_dict: Optional[dict] = None, mask_ip2: Optional[Any] = None,
+            model_ip2: str = "base", mode_ip2: str = "style", scale_ip2: float = 0.7,
+            pag_scale: float = 0.0,
+            face_restoration_model: Optional[str] = None,
+            face_restoration_visibility: float = 1.0,
+            face_restoration_weight: float = 0.5,
+            # 118..120 tail
+            load_lora_cpu: bool = False,
+            verbose_info_gui: int = 0,
+            gpu_duration: int = 20,
+        ) -> Tuple[str, Optional[List[str]], Optional[str]]:
+            raise NotImplementedError
+
+        # 2) Helpers: loader + argv builder
+        def _load_model(model_name: str, vae_model: str, task: str, controlnet_model: str) -> None:
+            for _ in sd_gen.load_new_model(model_name, vae_model, task, controlnet_model):
+                pass
+
+        # Order matches sd_gen_generate_pipeline(*argv)
+        _GEN_ARG_ORDER = [
+            # keep in sync with _signature_src and pipeline
+            "prompt","negative_prompt","num_images","num_inference_steps","guidance_scale","clip_skip","seed",
+            "lora1","lora1_wt","lora2","lora2_wt","lora3","lora3_wt","lora4","lora4_wt","lora5","lora5_wt","lora6","lora6_wt","lora7","lora7_wt",
+            "sampler","schedule_type","schedule_prediction_type",
+            "height","width","model_name","vae_model","task",
+            "image_control_dict","preprocessor_name","preprocess_resolution","image_resolution",
+            "style_prompt","style_json","image_mask",
+            "strength","low_threshold","high_threshold","value_threshold","distance_threshold",
+            "recolor_gamma_correction","tile_blur_sigma",
+            "control_net_output_scaling","control_net_start_threshold","control_net_stop_threshold",
+            "textual_inversion","prompt_syntax",
+            "upscaler_model_path","upscaler_increases_size","upscaler_tile_size","upscaler_tile_overlap",
+            "hires_steps","hires_denoising_strength","hires_sampler","hires_prompt","hires_negative_prompt",
+            "adetailer_inpaint_only","adetailer_verbose","hires_schedule_type","hires_guidance_scale",
+            "controlnet_model",
+            "loop_generation","leave_progress_bar","disable_progress_bar","image_previews","display_images","save_generated_images",
+            "filename_pattern","image_storage_location",
+            "retain_compel_previous_load","retain_detailfix_model_previous_load","retain_hires_model_previous_load",
+            "t2i_adapter_preprocessor","t2i_adapter_conditioning_scale","t2i_adapter_conditioning_factor",
+            "xformers_memory_efficient_attention","free_u","generator_in_cpu",
+            "adetailer_sampler",
+            "adetailer_active_a","prompt_ad_a","negative_prompt_ad_a","strength_ad_a",
+            "face_detector_ad_a","person_detector_ad_a","hand_detector_ad_a",
+            "mask_dilation_a","mask_blur_a","mask_padding_a",
+            "adetailer_active_b","prompt_ad_b","negative_prompt_ad_b","strength_ad_b",
+            "face_detector_ad_b","person_detector_ad_b","hand_detector_ad_b",
+            "mask_dilation_b","mask_blur_b","mask_padding_b",
+            "cache_compel_texts","guidance_rescale",
+            "image_ip1_dict","mask_ip1","model_ip1","mode_ip1","scale_ip1",
+            "image_ip2_dict","mask_ip2","model_ip2","mode_ip2","scale_ip2",
+            "pag_scale","face_restoration_model","face_restoration_visibility","face_restoration_weight",
+            "load_lora_cpu","verbose_info_gui","gpu_duration",
+        ]
+
+        def _argv_from_kwargs(kwargs: Dict[str, Any]) -> List[Any]:
+            # Convert kwargs to the exact positional argv expected by generator.
+            return [kwargs.get(k) for k in _GEN_ARG_ORDER]
+
+        def _generate_image(argv: List[Any]) -> Generator[Tuple[str, Optional[List[str]], Optional[str]], None, None]:
+            # Delegate to existing generator
+            yield from sd_gen_generate_pipeline(*argv)
+
+        # 3) Signature-clone decorator: keep one signature across both endpoints
+        def clone_signature(src):
+            def deco(dst):
+                dst.__signature__ = inspect.signature(src)
+                dst.__annotations__ = src.__annotations__.copy()
+                return dst
+            return deco
+
+        # 4) Implementations: both share the same signature via clone_signature
+        @clone_signature(_signature_src)
+        def generate_image(*, **kwargs) -> Tuple[str, Optional[List[str]], Optional[str]]:
+            _load_model(kwargs["model_name"], kwargs["vae_model"], kwargs["task"], kwargs["controlnet_model"])
+            argv = _argv_from_kwargs(kwargs)
+            last = ("COMPLETE", None, None)
+            for last in _generate_image(argv):
+                pass
+            return last
+
+        @clone_signature(_signature_src)
+        def generate_image_stream(*, **kwargs) -> Generator[Tuple[str, Optional[List[str]], Optional[str]], None, None]:
+            _load_model(kwargs["model_name"], kwargs["vae_model"], kwargs["task"], kwargs["controlnet_model"])
+            argv = _argv_from_kwargs(kwargs)
+            yield from _generate_image(argv)
+
+        # 5) Register two APIs with identical, named kwargs
+        gr.api(generate_image, api_name="generate_image", show_api=True, queue=True, concurrency_id="gpu")
+        gr.api(generate_image_stream, api_name="generate_image_stream", show_api=True, queue=True, concurrency_id="gpu")
 
     gr.LoginButton()
     gr.DuplicateButton(value="Duplicate Space for private use (This demo does not work on CPU. Requires GPU Space)")