Revert "Merge branch 'dev' into master"

This reverts commit 4b91ee0044, reversing
changes made to fc7e3c5721.

modules/api/api.py

@@ -356,54 +356,68 @@ class Api:
 
     def extras_batch_images_api(self, req: models.ExtrasBatchImagesRequest):
         reqDict = setUpscalers(req)
+
         image_list = reqDict.pop('imageList', [])
         image_folder = [decode_base64_to_image(x.data) for x in image_list]
+
         with self.queue_lock:
             result = postprocessing.run_extras(extras_mode=1, image_folder=image_folder, image="", input_dir="", output_dir="", save_output=False, **reqDict)
+
         return models.ExtrasBatchImagesResponse(images=list(map(encode_pil_to_base64, result[0])), html_info=result[1])
 
     def pnginfoapi(self, req: models.PNGInfoRequest):
         if not req.image.strip():
             return models.PNGInfoResponse(info="")
+
         image = decode_base64_to_image(req.image.strip())
         if image is None:
             return models.PNGInfoResponse(info="")
+
         geninfo, items = images.read_info_from_image(image)
         if geninfo is None:
             geninfo = ""
+
         items = {**{'parameters': geninfo}, **items}
+
         return models.PNGInfoResponse(info=geninfo, items=items)
 
     def progressapi(self, req: models.ProgressRequest = Depends()):
+        # copy from check_progress_call of ui.py
+
         if shared.state.job_count == 0:
             return models.ProgressResponse(progress=0, eta_relative=0, state=shared.state.dict(), textinfo=shared.state.textinfo)
 
+        # avoid dividing zero
+        progress = 0.01
+
+        if shared.state.job_count > 0:
+            progress += shared.state.job_no / shared.state.job_count
+        if shared.state.sampling_steps > 0:
+            progress += 1 / shared.state.job_count * shared.state.sampling_step / shared.state.sampling_steps
+
+        time_since_start = time.time() - shared.state.time_start
+        eta = time_since_start / progress
+        eta_relative = eta-time_since_start
+
+        progress = min(progress, 1)
+
         shared.state.set_current_image()
+
         current_image = None
         if shared.state.current_image and not req.skip_current_image:
             current_image = encode_pil_to_base64(shared.state.current_image)
 
-        batch_x = max(shared.state.job_no, 0)
-        batch_y = max(shared.state.job_count, 1)
-        step_x = max(shared.state.sampling_step, 0)
-        step_y = max(shared.state.sampling_steps, 1)
-        current = step_y * batch_x + step_x
-        total = step_y * batch_y
-        progress = current / total if total > 0 else 0
-
-        time_since_start = time.time() - shared.state.time_start
-        eta_relative = (time_since_start / progress) - time_since_start
-
-        res = models.ProgressResponse(progress=progress, eta_relative=eta_relative, state=shared.state.dict(), current_image=current_image, textinfo=shared.state.textinfo)
-        return res
-
+        return models.ProgressResponse(progress=progress, eta_relative=eta_relative, state=shared.state.dict(), current_image=current_image, textinfo=shared.state.textinfo)
 
     def interrogateapi(self, interrogatereq: models.InterrogateRequest):
         image_b64 = interrogatereq.image
         if image_b64 is None:
             raise HTTPException(status_code=404, detail="Image not found")
+
         img = decode_base64_to_image(image_b64)
         img = img.convert('RGB')
+
+        # Override object param
         with self.queue_lock:
             if interrogatereq.model == "clip":
                 processed = shared.interrogator.interrogate(img)
@@ -411,6 +425,7 @@ class Api:
                 processed = deepbooru.model.tag(img)
             else:
                 raise HTTPException(status_code=404, detail="Model not found")
+
         return models.InterrogateResponse(caption=processed)
 
     def interruptapi(self):
@@ -458,8 +473,18 @@ class Api:
     def get_sd_vaes(self):
         return [{"model_name": x, "filename": vae_dict[x]} for x in vae_dict.keys()]
 
+
     def get_upscalers(self):
-        return [{"name": upscaler.name, "model_name": upscaler.scaler.model_name, "model_path": upscaler.data_path, "model_url": None, "scale": upscaler.scale} for upscaler in shared.sd_upscalers]
+        return [
+            {
+                "name": upscaler.name,
+                "model_name": upscaler.scaler.model_name,
+                "model_path": upscaler.data_path,
+                "model_url": None,
+                "scale": upscaler.scale,
+            }
+            for upscaler in shared.sd_upscalers
+        ]
 
     def get_sd_models(self):
         return [{"title": x.title, "name": x.name, "filename": x.filename, "type": x.type, "hash": x.shorthash, "sha256": x.sha256, "config": find_checkpoint_config_near_filename(x)} for x in checkpoints_list.values()]
@@ -475,13 +500,23 @@ class Api:
 
     def get_embeddings(self):
         db = sd_hijack.model_hijack.embedding_db
+
         def convert_embedding(embedding):
-            return {"step": embedding.step, "sd_checkpoint": embedding.sd_checkpoint, "sd_checkpoint_name": embedding.sd_checkpoint_name, "shape": embedding.shape, "vectors": embedding.vectors}
+            return {
+                "step": embedding.step,
+                "sd_checkpoint": embedding.sd_checkpoint,
+                "sd_checkpoint_name": embedding.sd_checkpoint_name,
+                "shape": embedding.shape,
+                "vectors": embedding.vectors,
+            }
 
         def convert_embeddings(embeddings):
             return {embedding.name: convert_embedding(embedding) for embedding in embeddings.values()}
 
-        return {"loaded": convert_embeddings(db.word_embeddings), "skipped": convert_embeddings(db.skipped_embeddings)}
+        return {
+            "loaded": convert_embeddings(db.word_embeddings),
+            "skipped": convert_embeddings(db.skipped_embeddings),
+        }
 
     def get_extra_networks(self, page: Optional[str] = None, name: Optional[str] = None, filename: Optional[str] = None, title: Optional[str] = None, fullname: Optional[str] = None, hash: Optional[str] = None): # pylint: disable=redefined-builtin
         res = []
@@ -518,7 +553,7 @@ class Api:
 
     def create_embedding(self, args: dict):
         try:
-            shared.state.begin('api-embedding')
+            shared.state.begin('api-create-embedding')
             filename = create_embedding(**args) # create empty embedding
             sd_hijack.model_hijack.embedding_db.load_textual_inversion_embeddings() # reload embeddings so new one can be immediately used
             shared.state.end()
@@ -529,7 +564,7 @@ class Api:
 
     def create_hypernetwork(self, args: dict):
         try:
-            shared.state.begin('api-hypernetwork')
+            shared.state.begin('api-create-hypernetwork')
             filename = create_hypernetwork(**args) # create empty embedding # pylint: disable=E1111
             shared.state.end()
             return models.CreateResponse(info = f"create hypernetwork filename: {filename}")
@@ -555,7 +590,7 @@ class Api:
 
     def train_embedding(self, args: dict):
         try:
-            shared.state.begin('api-embedding')
+            shared.state.begin('api-train-embedding')
             apply_optimizations = False
             error = None
             filename = ''
@@ -576,7 +611,7 @@ class Api:
 
     def train_hypernetwork(self, args: dict):
         try:
-            shared.state.begin('api-hypernetwork')
+            shared.state.begin('api-train-hypernetwork')
             shared.loaded_hypernetworks = []
             apply_optimizations = False
             error = None

modules/extras.py

@@ -54,7 +54,7 @@ def to_half(tensor, enable):
 
 
 def run_modelmerger(id_task, primary_model_name, secondary_model_name, tertiary_model_name, interp_method, multiplier, save_as_half, custom_name, checkpoint_format, config_source, bake_in_vae, discard_weights, save_metadata): # pylint: disable=unused-argument
-    shared.state.begin('merge')
+    shared.state.begin('model-merge')
     save_as_half = save_as_half == 0
 
     def fail(message):
@@ -319,7 +319,7 @@ def run_modelconvert(model, checkpoint_formats, precision, conv_type, custom_nam
         "vae": vae_conv,
         "other": others_conv
     }
-    shared.state.begin('convert')
+    shared.state.begin('model-convert')
     model_info = sd_models.checkpoints_list[model]
     shared.state.textinfo = f"Loading {model_info.filename}..."
     shared.log.info(f"Model convert loading: {model_info.filename}")

modules/hashes.py

@@ -69,7 +69,7 @@ def sha256(filename, title, use_addnet_hash=False):
     if not os.path.isfile(filename):
         return None
     orig_state = copy.deepcopy(shared.state)
-    shared.state.begin("hash")
+    shared.state.begin("hashing")
     if use_addnet_hash:
         if progress_ok:
             try:

modules/hypernetworks/hypernetwork.py

@@ -460,7 +460,7 @@ def train_hypernetwork(id_task, hypernetwork_name, learn_rate, batch_size, gradi
     hypernetwork.load(path)
     shared.loaded_hypernetworks = [hypernetwork]
 
-    shared.state.job = "train"
+    shared.state.job = "train-hypernetwork"
     shared.state.textinfo = "Initializing hypernetwork training..."
     shared.state.job_count = steps
 

modules/images.py

@@ -135,9 +135,9 @@ def draw_grid_annotations(im, width, height, hor_texts, ver_texts, margin=0):
 
     def get_font(fontsize):
         try:
-            return ImageFont.truetype(shared.opts.font or 'javascript/roboto.ttf', fontsize)
+            return ImageFont.truetype(shared.opts.font or 'html/roboto.ttf', fontsize)
         except Exception:
-            return ImageFont.truetype('javascript/roboto.ttf', fontsize)
+            return ImageFont.truetype('html/roboto.ttf', fontsize)
 
     def draw_texts(drawing: ImageDraw, draw_x, draw_y, lines, initial_fnt, initial_fontsize):
         for line in lines:

modules/img2img.py

@@ -40,6 +40,7 @@ def process_batch(p, input_files, input_dir, output_dir, inpaint_mask_dir, args)
         btcrept = p.batch_size
         shared.log.info(f"Process batch: inputs={len(image_files)} outputs={p.n_iter * p.batch_size} per input")
     for i in range(0, len(image_files), window_size):
+        shared.state.job = f"{i+1} to {min(i+window_size, len(image_files))} out of {len(image_files)}"
         if shared.state.skipped:
             shared.state.skipped = False
         if shared.state.interrupted:

modules/modelloader.py

@@ -85,7 +85,7 @@ def download_civit_preview(model_path: str, preview_url: str):
     block_size = 16384 # 16KB blocks
     written = 0
     img = None
-    shared.state.begin('civitai')
+    shared.state.begin('civitai-download-preview')
     try:
         with open(preview_file, 'wb') as f:
             with p.Progress(p.TextColumn('[cyan]{task.description}'), p.DownloadColumn(), p.BarColumn(), p.TaskProgressColumn(), p.TimeRemainingColumn(), p.TimeElapsedColumn(), p.TransferSpeedColumn(), console=shared.console) as progress:
@@ -142,7 +142,7 @@ def download_civit_model_thread(model_name, model_url, model_path, model_type, p
     total_size = int(r.headers.get('content-length', 0))
     res += f' size={round((starting_pos + total_size)/1024/1024)}Mb'
     shared.log.info(res)
-    shared.state.begin('civitai')
+    shared.state.begin('civitai-download-model')
     block_size = 16384 # 16KB blocks
     written = starting_pos
     global download_pbar # pylint: disable=global-statement
@@ -188,7 +188,7 @@ def download_diffusers_model(hub_id: str, cache_dir: str = None, download_config
         return None
     from diffusers import DiffusionPipeline
     import huggingface_hub as hf
-    shared.state.begin('huggingface')
+    shared.state.begin('huggingface-download-model')
     if download_config is None:
         download_config = {
             "force_download": False,

modules/paths.py

@@ -17,13 +17,22 @@ extensions_builtin_dir = paths_internal.extensions_builtin_dir
 # data_path = cmd_opts_pre.data
 sys.path.insert(0, script_path)
 
-sd_path = os.path.join(script_path, 'repositories')
+# search for directory of stable diffusion in following places
+sd_path = None
+possible_sd_paths = [os.path.join(script_path, 'repositories/stable-diffusion-stability-ai'), '.', os.path.dirname(script_path)]
+for possible_sd_path in possible_sd_paths:
+    if os.path.exists(os.path.join(possible_sd_path, 'ldm/models/diffusion/ddpm.py')):
+        sd_path = os.path.abspath(possible_sd_path)
+        break
+
+assert sd_path is not None, f"Couldn't find Stable Diffusion in any of: {possible_sd_paths}"
+
 path_dirs = [
-    (sd_path, 'ldm', 'ldm', []),
-    (sd_path, 'taming', 'Taming Transformers', []),
-    (os.path.join(sd_path, 'blip'), 'models/blip.py', 'BLIP', []),
-    (os.path.join(sd_path, 'codeformer'), 'inference_codeformer.py', 'CodeFormer', []),
-    (os.path.join('modules', 'k-diffusion'), 'k_diffusion/sampling.py', 'k_diffusion', ["atstart"]),
+    (sd_path, 'ldm', 'Stable Diffusion', []),
+    (os.path.join(sd_path, '../taming-transformers'), 'taming', 'Taming Transformers', []),
+    (os.path.join(sd_path, '../CodeFormer'), 'inference_codeformer.py', 'CodeFormer', []),
+    (os.path.join(sd_path, '../BLIP'), 'models/blip.py', 'BLIP', []),
+    (os.path.join(sd_path, '../k-diffusion'), 'k_diffusion/sampling.py', 'k_diffusion', ["atstart"]),
 ]
 
 paths = {}

modules/processing.py

@@ -442,8 +442,6 @@ def decode_first_stage(model, x, full_quality=True):
         shared.log.debug(f'Decode VAE: skipped={shared.state.skipped} interrupted={shared.state.interrupted}')
         x_sample = torch.zeros((len(x), 3, x.shape[2] * 8, x.shape[3] * 8), dtype=devices.dtype_vae, device=devices.device)
         return x_sample
-    prev_job = shared.state.job
-    shared.state.job = 'vae'
     with devices.autocast(disable = x.dtype==devices.dtype_vae):
         try:
             if full_quality:
@@ -461,7 +459,6 @@ def decode_first_stage(model, x, full_quality=True):
         except Exception as e:
             x_sample = x
             shared.log.error(f'Decode VAE: {e}')
-    shared.state.job = prev_job
     return x_sample
 
 
@@ -772,11 +769,12 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
         return ''
 
     ema_scope_context = p.sd_model.ema_scope if shared.backend == shared.Backend.ORIGINAL else nullcontext
-    shared.state.job_count = p.n_iter
     with devices.inference_context(), ema_scope_context():
         t0 = time.time()
         with devices.autocast():
             p.init(p.all_prompts, p.all_seeds, p.all_subseeds)
+        if shared.state.job_count == -1:
+            shared.state.job_count = p.n_iter
         extra_network_data = None
         for n in range(p.n_iter):
             p.iteration = n
@@ -808,6 +806,8 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             step_multiplier = 1
             sampler_config = modules.sd_samplers.find_sampler_config(p.sampler_name)
             step_multiplier = 2 if sampler_config and sampler_config.options.get("second_order", False) else 1
+            if p.n_iter > 1:
+                shared.state.job = f"Batch {n+1} out of {p.n_iter}"
 
             if shared.backend == shared.Backend.ORIGINAL:
                 uc = get_conds_with_caching(modules.prompt_parser.get_learned_conditioning, p.negative_prompts, p.steps * step_multiplier, cached_uc)
@@ -913,6 +913,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
                         output_images.append(image_mask_composite)
             del x_samples_ddim
             devices.torch_gc()
+            shared.state.nextjob()
 
         t1 = time.time()
         shared.log.info(f'Processed: images={len(output_images)} time={t1 - t0:.2f}s its={(p.steps * len(output_images)) / (t1 - t0):.2f} memory={modules.memstats.memory_stats()}')
@@ -1035,8 +1036,12 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             self.is_hr_pass = False
             return
         self.is_hr_pass = True
+        if not shared.state.processing_has_refined_job_count:
+            if shared.state.job_count == -1:
+                shared.state.job_count = self.n_iter
+            shared.state.job_count = shared.state.job_count * 2
+            shared.state.processing_has_refined_job_count = True
         hypertile_set(self, hr=True)
-        shared.state.job_count = 2 * self.n_iter
         shared.log.debug(f'Init hires: upscaler="{self.hr_upscaler}" sampler="{self.latent_sampler}" resize={self.hr_resize_x}x{self.hr_resize_y} upscale={self.hr_upscale_to_x}x{self.hr_upscale_to_y}')
 
     def sample(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):
@@ -1056,13 +1061,11 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             self.sampler.initialize(self)
         x = create_random_tensors([4, self.height // 8, self.width // 8], seeds=seeds, subseeds=subseeds, subseed_strength=self.subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)
         samples = self.sampler.sample(self, x, conditioning, unconditional_conditioning, image_conditioning=self.txt2img_image_conditioning(x))
-        shared.state.nextjob()
         if not self.enable_hr or shared.state.interrupted or shared.state.skipped:
             return samples
 
         self.init_hr()
         if self.is_hr_pass:
-            prev_job = shared.state.job
             target_width = self.hr_upscale_to_x
             target_height = self.hr_upscale_to_y
             decoded_samples = None
@@ -1080,7 +1083,6 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
                     self.extra_generation_params, self.restore_faces = bak_extra_generation_params, bak_restore_faces
                     images.save_image(image, self.outpath_samples, "", seeds[i], prompts[i], shared.opts.samples_format, info=info, suffix="-before-hires")
             if latent_scale_mode is None or self.hr_force: # non-latent upscaling
-                shared.state.job = 'upscale'
                 if decoded_samples is None:
                     decoded_samples = decode_first_stage(self.sd_model, samples.to(dtype=devices.dtype_vae), self.full_quality)
                     decoded_samples = torch.clamp((decoded_samples + 1.0) / 2.0, min=0.0, max=1.0)
@@ -1110,7 +1112,6 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
                 if self.latent_sampler == "PLMS":
                     self.latent_sampler = 'UniPC'
             if self.hr_force or latent_scale_mode is not None:
-                shared.state.job = 'hires'
                 if self.denoising_strength > 0:
                     self.ops.append('hires')
                     devices.torch_gc() # GC now before running the next img2img to prevent running out of memory
@@ -1126,9 +1127,8 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
                 else:
                     self.ops.append('upscale')
             x = None
-            self.is_hr_pass = False
-            shared.state.job = prev_job
             shared.state.nextjob()
+            self.is_hr_pass = False
 
         return samples
 
@@ -1293,7 +1293,6 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
             samples = samples * self.nmask + self.init_latent * self.mask
         del x
         devices.torch_gc()
-        shared.state.nextjob()
         return samples
 
     def get_token_merging_ratio(self, for_hr=False):

modules/processing_diffusers.py

@@ -63,6 +63,14 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
 
     def diffusers_callback(step: int, _timestep: int, latents: torch.FloatTensor):
         shared.state.sampling_step = step
+        if p.is_hr_pass:
+            shared.state.job = 'hires'
+            shared.state.sampling_steps = p.hr_second_pass_steps # add optional hires
+        elif p.is_refiner_pass:
+            shared.state.job = 'refine'
+            shared.state.sampling_steps = calculate_refiner_steps() # add optional refiner
+        else:
+            shared.state.sampling_steps = p.steps # base steps
         shared.state.current_latent = latents
         if shared.state.interrupted or shared.state.skipped:
             raise AssertionError('Interrupted...')
@@ -125,8 +133,6 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
         return encoded
 
     def vae_decode(latents, model, output_type='np', full_quality=True):
-        prev_job = shared.state.job
-        shared.state.job = 'vae'
         if not torch.is_tensor(latents): # already decoded
             return latents
         if latents.shape[0] == 0:
@@ -144,7 +150,6 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
         else:
             decoded = taesd_vae_decode(latents=latents)
         imgs = model.image_processor.postprocess(decoded, output_type=output_type)
-        shared.state.job = prev_job
         return imgs
 
     def vae_encode(image, model, full_quality=True): # pylint: disable=unused-variable
@@ -181,17 +186,16 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
 
     def task_specific_kwargs(model):
         task_args = {}
-        is_img2img_model = bool("Zero123" in shared.sd_model.__class__.__name__)
-        if sd_models.get_diffusers_task(model) == sd_models.DiffusersTaskType.TEXT_2_IMAGE and not is_img2img_model:
+        if sd_models.get_diffusers_task(model) == sd_models.DiffusersTaskType.TEXT_2_IMAGE:
             p.ops.append('txt2img')
             task_args = {"height": 8 * math.ceil(p.height / 8), "width": 8 * math.ceil(p.width / 8)}
-        elif (sd_models.get_diffusers_task(model) == sd_models.DiffusersTaskType.IMAGE_2_IMAGE or is_img2img_model) and len(getattr(p, 'init_images' ,[])) > 0:
+        elif sd_models.get_diffusers_task(model) == sd_models.DiffusersTaskType.IMAGE_2_IMAGE and len(getattr(p, 'init_images' ,[])) > 0:
             p.ops.append('img2img')
             task_args = {"image": p.init_images, "strength": p.denoising_strength}
         elif sd_models.get_diffusers_task(model) == sd_models.DiffusersTaskType.INSTRUCT and len(getattr(p, 'init_images' ,[])) > 0:
             p.ops.append('instruct')
             task_args = {"height": 8 * math.ceil(p.height / 8), "width": 8 * math.ceil(p.width / 8), "image": p.init_images, "strength": p.denoising_strength}
-        elif (sd_models.get_diffusers_task(model) == sd_models.DiffusersTaskType.INPAINTING or is_img2img_model) and len(getattr(p, 'init_images' ,[])) > 0:
+        elif sd_models.get_diffusers_task(model) == sd_models.DiffusersTaskType.INPAINTING and len(getattr(p, 'init_images' ,[])) > 0:
             p.ops.append('inpaint')
             if getattr(p, 'mask', None) is None:
                 p.mask = TF.to_pil_image(torch.ones_like(TF.to_tensor(p.init_images[0]))).convert("L")
@@ -384,7 +388,6 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
         clip_skip=p.clip_skip,
         desc='Base',
     )
-    shared.state.sampling_steps = base_args['num_inference_steps']
     p.extra_generation_params['CFG rescale'] = p.diffusers_guidance_rescale
     p.extra_generation_params["Sampler Eta"] = shared.opts.scheduler_eta if shared.opts.scheduler_eta is not None and shared.opts.scheduler_eta > 0 and shared.opts.scheduler_eta < 1 else None
     try:
@@ -400,7 +403,6 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
     if hasattr(shared.sd_model, 'embedding_db') and len(shared.sd_model.embedding_db.embeddings_used) > 0:
         p.extra_generation_params['Embeddings'] = ', '.join(shared.sd_model.embedding_db.embeddings_used)
 
-    shared.state.nextjob()
     if shared.state.interrupted or shared.state.skipped:
         return results
 
@@ -410,12 +412,10 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
     latent_scale_mode = shared.latent_upscale_modes.get(p.hr_upscaler, None) if (hasattr(p, "hr_upscaler") and p.hr_upscaler is not None) else shared.latent_upscale_modes.get(shared.latent_upscale_default_mode, "None")
     if p.is_hr_pass:
         p.init_hr()
-        prev_job = shared.state.job
         if p.width != p.hr_upscale_to_x or p.height != p.hr_upscale_to_y:
             p.ops.append('upscale')
             if shared.opts.save and not p.do_not_save_samples and shared.opts.save_images_before_highres_fix and hasattr(shared.sd_model, 'vae'):
                 save_intermediate(latents=output.images, suffix="-before-hires")
-            shared.state.job = 'upscale'
             output.images = hires_resize(latents=output.images)
             if latent_scale_mode is not None or p.hr_force:
                 p.ops.append('hires')
@@ -438,22 +438,15 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
                     strength=p.denoising_strength,
                     desc='Hires',
                 )
-                shared.state.job = 'hires'
-                shared.state.sampling_steps = hires_args['num_inference_steps']
                 try:
                     output = shared.sd_model(**hires_args) # pylint: disable=not-callable
                 except AssertionError as e:
                     shared.log.info(e)
                 p.init_images = []
-        shared.state.job = prev_job
-        shared.state.nextjob()
         p.is_hr_pass = False
 
     # optional refiner pass or decode
     if is_refiner_enabled:
-        prev_job = shared.state.job
-        shared.state.job = 'refine'
-        shared.state.job_count +=1
         if shared.opts.save and not p.do_not_save_samples and shared.opts.save_images_before_refiner and hasattr(shared.sd_model, 'vae'):
             save_intermediate(latents=output.images, suffix="-before-refiner")
         if shared.opts.diffusers_move_base and not getattr(shared.sd_model, 'has_accelerate', False):
@@ -498,7 +491,6 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
                 clip_skip=p.clip_skip,
                 desc='Refiner',
             )
-            shared.state.sampling_steps = refiner_args['num_inference_steps']
             try:
                 refiner_output = shared.sd_refiner(**refiner_args) # pylint: disable=not-callable
             except AssertionError as e:
@@ -513,9 +505,7 @@ def process_diffusers(p: StableDiffusionProcessing, seeds, prompts, negative_pro
             shared.log.debug('Moving to CPU: model=refiner')
             shared.sd_refiner.to(devices.cpu)
             devices.torch_gc()
-        shared.state.job = prev_job
-        shared.state.nextjob()
-        p.is_refiner_pass = False
+        p.is_refiner_pass = True
 
     # final decode since there is no refiner
     if not is_refiner_enabled:

modules/progress.py

@@ -66,20 +66,15 @@ def progressapi(req: ProgressRequest):
     paused = shared.state.paused
     if not active:
         return InternalProgressResponse(job=shared.state.job, active=active, queued=queued, paused=paused, completed=completed, id_live_preview=-1, textinfo="Queued..." if queued else "Waiting...")
-    if shared.state.job_no > shared.state.job_count:
-        shared.state.job_count = shared.state.job_no
-    batch_x = max(shared.state.job_no, 0)
-    batch_y = max(shared.state.job_count, 1)
-    step_x = max(shared.state.sampling_step, 0)
-    step_y = max(shared.state.sampling_steps, 1)
-    current = step_y * batch_x + step_x
-    total = step_y * batch_y
-    progress = min(1, current / total if total > 0 else 0)
-
+    progress = 0
+    if shared.state.job_count > 0:
+        progress += shared.state.job_no / shared.state.job_count
+    if shared.state.sampling_steps > 0 and shared.state.job_count > 0:
+        progress += 1 / (shared.state.job_count / 2 if shared.state.processing_has_refined_job_count else 1) * shared.state.sampling_step / shared.state.sampling_steps
+    progress = min(progress, 1)
     elapsed_since_start = time.time() - shared.state.time_start
     predicted_duration = elapsed_since_start / progress if progress > 0 else None
     eta = predicted_duration - elapsed_since_start if predicted_duration is not None else None
-
     id_live_preview = req.id_live_preview
     live_preview = None
     shared.state.set_current_image()
@@ -88,6 +83,4 @@ def progressapi(req: ProgressRequest):
         shared.state.current_image.save(buffered, format='jpeg')
         live_preview = f'data:image/jpeg;base64,{base64.b64encode(buffered.getvalue()).decode("ascii")}'
         id_live_preview = shared.state.id_live_preview
-
-    res = InternalProgressResponse(job=shared.state.job, active=active, queued=queued, paused=paused, completed=completed, progress=progress, eta=eta, live_preview=live_preview, id_live_preview=id_live_preview, textinfo=shared.state.textinfo)
-    return res
+    return InternalProgressResponse(job=shared.state.job, active=active, queued=queued, paused=paused, completed=completed, progress=progress, eta=eta, live_preview=live_preview, id_live_preview=id_live_preview, textinfo=shared.state.textinfo)

modules/scripts.py

@@ -321,7 +321,6 @@ class ScriptRunner:
         self.paste_field_names = []
         self.script_load_ctr = 0
         self.is_img2img = False
-        self.inputs = [None]
 
     def initialize_scripts(self, is_img2img):
         from modules import scripts_auto_postprocessing
@@ -356,31 +355,6 @@ class ScriptRunner:
             except Exception as e:
                 log.error(f'Script initialize: {path} {e}')
 
-    def create_script_ui(self, script):
-        import modules.api.models as api_models
-        script.args_from = len(self.inputs)
-        script.args_to = len(self.inputs)
-        controls = wrap_call(script.ui, script.filename, "ui", script.is_img2img)
-        if controls is None:
-            return
-        script.name = wrap_call(script.title, script.filename, "title", default=script.filename).lower()
-        api_args = []
-        for control in controls:
-            control.custom_script_source = os.path.basename(script.filename)
-            arg_info = api_models.ScriptArg(label=control.label or "")
-            for field in ("value", "minimum", "maximum", "step", "choices"):
-                v = getattr(control, field, None)
-                if v is not None:
-                    setattr(arg_info, field, v)
-            api_args.append(arg_info)
-        script.api_info = api_models.ScriptInfo(name=script.name, is_img2img=script.is_img2img, is_alwayson=script.alwayson, args=api_args)
-        if script.infotext_fields is not None:
-            self.infotext_fields += script.infotext_fields
-        if script.paste_field_names is not None:
-            self.paste_field_names += script.paste_field_names
-        self.inputs += controls
-        script.args_to = len(self.inputs)
-
     def setup_ui_for_section(self, section, scriptlist=None):
         if scriptlist is None:
             scriptlist = self.alwayson_scripts
@@ -403,7 +377,7 @@ class ScriptRunner:
         inputs = []
         inputs_alwayson = [True]
 
-        def create_script_ui(script, inputs, inputs_alwayson): # TODO this is legacy implementation, see self.create_script_ui
+        def create_script_ui(script, inputs, inputs_alwayson):
             script.args_from = len(inputs)
             script.args_to = len(inputs)
             controls = wrap_call(script.ui, script.filename, "ui", script.is_img2img)

modules/sd_hijack_optimizations.py

@@ -317,7 +317,7 @@ def get_xformers_flash_attention_op(q, k, v):
         return None
 
     try:
-        flash_attention_op = xformers.ops.MemoryEfficientAttentionFlashAttentionOp # pylint: disable=used-before-assignment
+        flash_attention_op = xformers.ops.MemoryEfficientAttentionFlashAttentionOp
         fw, _bw = flash_attention_op
         if fw.supports(xformers.ops.fmha.Inputs(query=q, key=k, value=v, attn_bias=None)):
             return flash_attention_op

modules/sd_models.py

@@ -848,8 +848,6 @@ def load_diffuser(checkpoint_info=None, already_loaded_state_dict=None, timer=No
             vae = sd_vae.load_vae_diffusers(checkpoint_info.path, vae_file, vae_source)
             if vae is not None:
                 diffusers_load_config["vae"] = vae
-            if 'LCM' in checkpoint_info.path:
-                diffusers_load_config['custom_pipeline'] = 'latent_consistency_txt2img'
 
         if os.path.isdir(checkpoint_info.path):
             err1 = None
@@ -860,21 +858,18 @@ def load_diffuser(checkpoint_info=None, already_loaded_state_dict=None, timer=No
                 sd_model.model_type = sd_model.__class__.__name__
             except Exception as e:
                 err1 = e
-                # shared.log.error(f'AutoPipeline: {e}')
             try: # try diffusion pipeline next second-best choice, works for most non-linked pipelines
                 if err1 is not None:
                     sd_model = diffusers.DiffusionPipeline.from_pretrained(checkpoint_info.path, cache_dir=shared.opts.diffusers_dir, **diffusers_load_config)
                     sd_model.model_type = sd_model.__class__.__name__
             except Exception as e:
                 err2 = e
-                # shared.log.error(f'DiffusionPipeline: {e}')
             try: # try basic pipeline next just in case
                 if err2 is not None:
                     sd_model = diffusers.StableDiffusionPipeline.from_pretrained(checkpoint_info.path, cache_dir=shared.opts.diffusers_dir, **diffusers_load_config)
                     sd_model.model_type = sd_model.__class__.__name__
             except Exception as e:
                 err3 = e # ignore last error
-                shared.log.error(f'StableDiffusionPipeline: {e}')
             if err3 is not None:
                 shared.log.error(f'Failed loading {op}: {checkpoint_info.path} auto={err1} diffusion={err2}')
                 return
@@ -1160,7 +1155,7 @@ def reload_model_weights(sd_model=None, info=None, reuse_dict=False, op='model')
         return None
     orig_state = copy.deepcopy(shared.state)
     shared.state = shared_state.State()
-    shared.state.begin('load')
+    shared.state.begin(f'load-{op}')
     if load_dict:
         shared.log.debug(f'Model dict: existing={sd_model is not None} target={checkpoint_info.filename} info={info}')
     else:

modules/sd_models_config.py

@@ -4,10 +4,10 @@ import torch
 
 from modules import paths, sd_disable_initialization, devices
 
-sd_repo_configs_path = 'configs'
+sd_repo_configs_path = os.path.join(paths.paths['Stable Diffusion'], "configs", "stable-diffusion")
 config_default = paths.sd_default_config
-config_sd2 = os.path.join(sd_repo_configs_path, "v2-inference-512-base.yaml")
-config_sd2v = os.path.join(sd_repo_configs_path, "v2-inference-768-v.yaml")
+config_sd2 = os.path.join(sd_repo_configs_path, "v2-inference.yaml")
+config_sd2v = os.path.join(sd_repo_configs_path, "v2-inference-v.yaml")
 config_sd2_inpainting = os.path.join(sd_repo_configs_path, "v2-inpainting-inference.yaml")
 config_depth_model = os.path.join(sd_repo_configs_path, "v2-midas-inference.yaml")
 config_unclip = os.path.join(sd_repo_configs_path, "v2-1-stable-unclip-l-inference.yaml")

modules/sd_samplers_timesteps.py

@@ -49,7 +49,6 @@ class CFGDenoiserTimesteps(CFGDenoiser):
 
         self.alphas = shared.sd_model.alphas_cumprod
         self.mask_before_denoising = True
-        self.model_wrap = None
 
     def get_pred_x0(self, x_in, x_out, sigma):
         ts = sigma.to(dtype=int)

modules/shared.py

@@ -474,7 +474,7 @@ options_templates.update(options_section(('sampler-params', "Sampler Settings"),
     "schedulers_use_karras": OptionInfo(True, "Use Karras sigmas", gr.Checkbox, {"visible": False}),
     "schedulers_use_thresholding": OptionInfo(False, "Use dynamic thresholding", gr.Checkbox, {"visible": False}),
     "schedulers_use_loworder": OptionInfo(True, "Use simplified solvers in final steps", gr.Checkbox, {"visible": False}),
-    "schedulers_prediction_type": OptionInfo("default", "Override model prediction type", gr.Radio, {"choices": ['default', 'epsilon', 'sample', 'v_prediction']}),
+    "schedulers_prediction_type": OptionInfo("default", "Override model prediction type", gr.Radio, {"choices": ['default', 'epsilon', 'sample', 'v_prediction'], "visible": False}),
 
     # managed from ui.py for backend diffusers
     "schedulers_sep_diffusers": OptionInfo("<h2>Diffusers specific config</h2>", "", gr.HTML),

modules/shared_state.py

@@ -13,6 +13,7 @@ class State:
     job_no = 0
     job_count = 0
     total_jobs = 0
+    processing_has_refined_job_count = False
     job_timestamp = '0'
     sampling_step = 0
     sampling_steps = 0
@@ -71,6 +72,7 @@ class State:
         self.job_no = 0
         self.job_timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
         self.paused = False
+        self.processing_has_refined_job_count = False
         self.sampling_step = 0
         self.skipped = False
         self.textinfo = None

modules/textual_inversion/image_embedding.py

@@ -133,7 +133,7 @@ def caption_image_overlay(srcimage, title, footerLeft, footerMid, footerRight, t
     image = srcimage.copy()
     fontsize = 32
     if textfont is None:
-        textfont = opts.font or 'javascript/roboto.ttf'
+        textfont = opts.font or 'html/roboto.ttf'
 
     factor = 1.5
     gradient = Image.new('RGBA', (1, image.size[1]), color=(0, 0, 0, 0))

modules/textual_inversion/textual_inversion.py

@@ -425,7 +425,7 @@ def train_embedding(id_task, embedding_name, learn_rate, batch_size, gradient_st
         log_directory = f"{os.path.join(shared.cmd_opts.data_dir, 'train/log/embeddings')}"
     template_file = template_file.path
 
-    shared.state.job = "train"
+    shared.state.job = "train-embedding"
     shared.state.textinfo = "Initializing textual inversion training..."
     shared.state.job_count = steps
 

modules/ui_prompt_styles.py

@@ -1,7 +1,8 @@
 # TODO: a1111 compatibility item, not used
 
 import gradio as gr
-from modules import shared, styles
+
+from modules import shared, ui_common, ui_components, styles
 
 styles_edit_symbol = '\U0001f58c\uFE0F'  # 🖌️
 styles_materialize_symbol = '\U0001f4cb'  # 📋
@@ -33,7 +34,7 @@ def delete_style(name):
     return '', '', ''
 
 
-def materialize_styles(prompt, negative_prompt, styles): # pylint: disable=redefined-outer-name
+def materialize_styles(prompt, negative_prompt, styles):
     prompt = shared.prompt_styles.apply_styles_to_prompt(prompt, styles)
     negative_prompt = shared.prompt_styles.apply_negative_styles_to_prompt(negative_prompt, styles)
     return [gr.Textbox.update(value=prompt), gr.Textbox.update(value=negative_prompt), gr.Dropdown.update(value=[])]
@@ -44,7 +45,7 @@ def refresh_styles():
 
 
 class UiPromptStyles:
-    def __init__(self, tabname, main_ui_prompt, main_ui_negative_prompt): # pylint: disable=unused-argument
+    def __init__(self, tabname, main_ui_prompt, main_ui_negative_prompt):
         self.dropdown = gr.Dropdown(label="Styles", elem_id=f"{tabname}_styles", choices=[style.name for style in shared.prompt_styles.styles.values()], value=[], multiselect=True)
 
     """