From cd580866a7f82e6ace975cff80f1f46586a2988e Mon Sep 17 00:00:00 2001 From: Vladimir Mandic Date: Sat, 29 Apr 2023 12:37:33 -0400 Subject: [PATCH] fix awalys on script args --- extensions-builtin/sd-webui-controlnet | 2 +- modules/api/api.py | 118 +++++++++---------------- modules/api/models.py | 36 ++++---- modules/cmd_args.py | 2 +- modules/img2img.py | 2 +- modules/processing.py | 1 + modules/scripts.py | 28 +++--- modules/txt2img.py | 2 +- setup.py | 2 +- 9 files changed, 77 insertions(+), 116 deletions(-) diff --git a/extensions-builtin/sd-webui-controlnet b/extensions-builtin/sd-webui-controlnet index 940d4edfb..d520e9da0 160000 --- a/extensions-builtin/sd-webui-controlnet +++ b/extensions-builtin/sd-webui-controlnet @@ -1 +1 @@ -Subproject commit 940d4edfbab1525615b1827a9cb7b7ea21af8a6c +Subproject commit d520e9da0014073162817ceb1eae241bccba67b9 diff --git a/modules/api/api.py b/modules/api/api.py index 976b53b57..0717edfaf 100644 --- a/modules/api/api.py +++ b/modules/api/api.py @@ -17,7 +17,7 @@ from gradio.processing_utils import decode_base64_to_file # from gradio_client.utils import decode_base64_to_file from modules import errors, shared, sd_samplers, deepbooru, sd_hijack, images, scripts, ui, postprocessing -from modules.api.models import * +from modules.api.models import * # pylint: disable=unused-wildcard-import, wildcard-import from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img, process_images from modules.textual_inversion.textual_inversion import create_embedding, train_embedding from modules.textual_inversion.preprocess import preprocess @@ -32,20 +32,19 @@ errors.install() def upscaler_to_index(name: str): try: return [x.name.lower() for x in shared.sd_upscalers].index(name.lower()) - except: - raise HTTPException(status_code=400, detail=f"Invalid upscaler, needs to be one of these: {' , '.join([x.name for x in sd_upscalers])}") + except Exception as e: + raise HTTPException(status_code=400, detail=f"Invalid upscaler, needs to be one of these: {' , '.join([x.name for x in sd_upscalers])}") from e def script_name_to_index(name, scripts_list): try: return [script.title().lower() for script in scripts_list].index(name.lower()) - except: - raise HTTPException(status_code=422, detail=f"Script '{name}' not found") + except Exception as e: + raise HTTPException(status_code=422, detail=f"Script '{name}' not found") from e def validate_sampler_name(name): config = sd_samplers.all_samplers_map.get(name, None) if config is None: raise HTTPException(status_code=404, detail="Sampler not found") - return name def setUpscalers(req: dict): @@ -60,20 +59,19 @@ def decode_base64_to_image(encoding): try: image = Image.open(BytesIO(base64.b64decode(encoding))) return image - except Exception: - raise HTTPException(status_code=500, detail="Invalid encoded image") + except Exception as e: + raise HTTPException(status_code=500, detail="Invalid encoded image") from e def encode_pil_to_base64(image): with io.BytesIO() as output_bytes: - if opts.samples_format.lower() == 'png': use_metadata = False - metadata = PngImagePlugin.PngInfo() - for key, value in image.info.items(): - if isinstance(key, str) and isinstance(value, str): - metadata.add_text(key, value) + encoded_metadata = PngImagePlugin.PngInfo() + for k, v in image.info.items(): + if isinstance(k, str) and isinstance(v, str): + encoded_metadata.add_text(k, v) use_metadata = True - image.save(output_bytes, format="PNG", pnginfo=(metadata if use_metadata else None), quality=opts.jpeg_quality) + image.save(output_bytes, format="PNG", pnginfo=(encoded_metadata if use_metadata else None), quality=opts.jpeg_quality) elif opts.samples_format.lower() in ("jpg", "jpeg", "webp"): parameters = image.info.get('parameters', None) @@ -84,12 +82,9 @@ def encode_pil_to_base64(image): image.save(output_bytes, format="JPEG", exif = exif_bytes, quality=opts.jpeg_quality) else: image.save(output_bytes, format="WEBP", exif = exif_bytes, quality=opts.jpeg_quality) - else: raise HTTPException(status_code=500, detail="Invalid image format") - bytes_data = output_bytes.getvalue() - return base64.b64encode(bytes_data) @@ -100,7 +95,6 @@ class Api: for auth in shared.cmd_opts.api_auth.split(","): user, password = auth.split(":") self.credentials[user] = password - self.router = APIRouter() self.app = app self.queue_lock = queue_lock @@ -135,7 +129,6 @@ class Api: self.add_api_route("/sdapi/v1/unload-checkpoint", self.unloadapi, methods=["POST"]) self.add_api_route("/sdapi/v1/reload-checkpoint", self.reloadapi, methods=["POST"]) self.add_api_route("/sdapi/v1/scripts", self.get_scripts_list, methods=["GET"], response_model=ScriptsList) - self.default_script_arg_txt2img = [] self.default_script_arg_img2img = [] @@ -148,13 +141,11 @@ class Api: if credentials.username in self.credentials: if compare_digest(credentials.password, self.credentials[credentials.username]): return True - raise HTTPException(status_code=401, detail="Incorrect username or password", headers={"WWW-Authenticate": "Basic"}) def get_selectable_script(self, script_name, script_runner): if script_name is None or script_name == "": return None, None - script_idx = script_name_to_index(script_name, script_runner.selectable_scripts) script = script_runner.selectable_scripts[script_idx] return script, script_idx @@ -162,13 +153,11 @@ class Api: def get_scripts_list(self): t2ilist = [str(title.lower()) for title in scripts.scripts_txt2img.titles] i2ilist = [str(title.lower()) for title in scripts.scripts_img2img.titles] - return ScriptsList(txt2img = t2ilist, img2img = i2ilist) def get_script(self, script_name, script_runner): if script_name is None or script_name == "": return None, None - script_idx = script_name_to_index(script_name, script_runner.scripts) return script_runner.scripts[script_idx] @@ -192,25 +181,17 @@ class Api: script_args[script.args_from:script.args_to] = ui_default_values return script_args - def init_script_args(self, request, default_script_args, selectable_scripts, selectable_idx, script_runner): + def init_script_args(self, p, request, default_script_args, script_runner): script_args = default_script_args.copy() - # position 0 in script_arg is the idx+1 of the selectable script that is going to be run when using scripts.scripts_*2img.run() - if selectable_scripts: - script_args[selectable_scripts.args_from:selectable_scripts.args_to] = request.script_args - script_args[0] = selectable_idx + 1 - - # Now check for always on scripts if request.alwayson_scripts and (len(request.alwayson_scripts) > 0): for alwayson_script_name in request.alwayson_scripts.keys(): alwayson_script = self.get_script(alwayson_script_name, script_runner) if alwayson_script is None: raise HTTPException(status_code=422, detail=f"always on script {alwayson_script_name} not found") - # Selectable script in always on script param check if not alwayson_script.alwayson: - raise HTTPException(status_code=422, detail=f"Cannot have a selectable script in the always on scripts params") - # always on script with no arg should always run so you don't really need to add them to the requests + raise HTTPException(status_code=422, detail="Cannot have a selectable script in the always on scripts params") if "args" in request.alwayson_scripts[alwayson_script_name]: - script_args[alwayson_script.args_from:alwayson_script.args_to] = request.alwayson_scripts[alwayson_script_name]["args"] + p.per_script_args[alwayson_script.title()] = request.alwayson_scripts[alwayson_script_name]["args"] + script_args return script_args def text2imgapi(self, txt2imgreq: StableDiffusionTxt2ImgProcessingAPI): @@ -220,8 +201,7 @@ class Api: ui.create_ui() if not self.default_script_arg_txt2img: self.default_script_arg_txt2img = self.init_default_script_args(script_runner) - selectable_scripts, selectable_script_idx = self.get_selectable_script(txt2imgreq.script_name, script_runner) - + selectable_scripts, _selectable_script_idx = self.get_selectable_script(txt2imgreq.script_name, script_runner) populate = txt2imgreq.copy(update={ # Override __init__ params "sampler_name": validate_sampler_name(txt2imgreq.sampler_name or txt2imgreq.sampler_index), "do_not_save_samples": not txt2imgreq.save_images, @@ -229,14 +209,10 @@ class Api: }) if populate.sampler_name: populate.sampler_index = None # prevent a warning later on - args = vars(populate) args.pop('script_name', None) args.pop('script_args', None) # will refeed them to the pipeline directly after initializing them args.pop('alwayson_scripts', None) - - script_args = self.init_script_args(txt2imgreq, self.default_script_arg_txt2img, selectable_scripts, selectable_script_idx, script_runner) - send_images = args.pop('send_images', True) args.pop('save_images', None) @@ -245,37 +221,32 @@ class Api: p.scripts = script_runner p.outpath_grids = opts.outdir_grids or opts.outdir_txt2img_grids p.outpath_samples = opts.outdir_samples or opts.outdir_txt2img_samples - shared.state.begin() + script_args = self.init_script_args(p, txt2imgreq, self.default_script_arg_txt2img, script_runner) if selectable_scripts is not None: - p.script_args = script_args - processed = scripts.scripts_txt2img.run(p, *p.script_args) # Need to pass args as list here + processed = scripts.scripts_txt2img.run(p, *script_args) # Need to pass args as list here else: p.script_args = tuple(script_args) # Need to pass args as tuple here processed = process_images(p) shared.state.end() b64images = list(map(encode_pil_to_base64, processed.images)) if send_images else [] - return TextToImageResponse(images=b64images, parameters=vars(txt2imgreq), info=processed.js()) def img2imgapi(self, img2imgreq: StableDiffusionImg2ImgProcessingAPI): init_images = img2imgreq.init_images if init_images is None: raise HTTPException(status_code=404, detail="Init image not found") - mask = img2imgreq.mask if mask: mask = decode_base64_to_image(mask) - script_runner = scripts.scripts_img2img if not script_runner.scripts: script_runner.initialize_scripts(True) ui.create_ui() if not self.default_script_arg_img2img: self.default_script_arg_img2img = self.init_default_script_args(script_runner) - selectable_scripts, selectable_script_idx = self.get_selectable_script(img2imgreq.script_name, script_runner) - + selectable_scripts, _selectable_script_idx = self.get_selectable_script(img2imgreq.script_name, script_runner) populate = img2imgreq.copy(update={ # Override __init__ params "sampler_name": validate_sampler_name(img2imgreq.sampler_name or img2imgreq.sampler_index), "do_not_save_samples": not img2imgreq.save_images, @@ -284,15 +255,11 @@ class Api: }) if populate.sampler_name: populate.sampler_index = None # prevent a warning later on - args = vars(populate) args.pop('include_init_images', None) # this is meant to be done by "exclude": True in model, but it's for a reason that I cannot determine. args.pop('script_name', None) args.pop('script_args', None) # will refeed them to the pipeline directly after initializing them args.pop('alwayson_scripts', None) - - script_args = self.init_script_args(img2imgreq, self.default_script_arg_img2img, selectable_scripts, selectable_script_idx, script_runner) - send_images = args.pop('send_images', True) args.pop('save_images', None) @@ -302,22 +269,19 @@ class Api: p.scripts = script_runner p.outpath_grids = opts.outdir_img2img_grids p.outpath_samples = opts.outdir_img2img_samples - shared.state.begin() + script_args = self.init_script_args(p, img2imgreq, self.default_script_arg_txt2img, script_runner) if selectable_scripts is not None: - p.script_args = script_args - processed = scripts.scripts_img2img.run(p, *p.script_args) # Need to pass args as list here + processed = scripts.scripts_img2img.run(p, *script_args) # Need to pass args as list here else: p.script_args = tuple(script_args) # Need to pass args as tuple here processed = process_images(p) shared.state.end() b64images = list(map(encode_pil_to_base64, processed.images)) if send_images else [] - if not img2imgreq.include_init_images: img2imgreq.init_images = None img2imgreq.mask = None - return ImageToImageResponse(images=b64images, parameters=vars(img2imgreq), info=processed.js()) def extras_single_image_api(self, req: ExtrasSingleImageRequest): @@ -429,12 +393,11 @@ class Api: def get_config(self): options = {} - for key in shared.opts.data.keys(): - metadata = shared.opts.data_labels.get(key) - if metadata is not None: - options.update({key: shared.opts.data.get(key, shared.opts.data_labels.get(key).default)}) + for k in shared.opts.data.keys(): + if shared.opts.data_labels.get(k) is not None: + options.update({k: shared.opts.data.get(k, shared.opts.data_labels.get(k).default)}) else: - options.update({key: shared.opts.data.get(key, None)}) + options.update({k: shared.opts.data.get(k, None)}) return options @@ -512,20 +475,20 @@ class Api: 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() - return CreateResponse(info = "create embedding filename: {filename}".format(filename = filename)) + return CreateResponse(info = f"create embedding filename: {filename}") except AssertionError as e: shared.state.end() - return TrainResponse(info = "create embedding error: {error}".format(error = e)) + return TrainResponse(info = f"create embedding error: {e}") def create_hypernetwork(self, args: dict): try: shared.state.begin() filename = create_hypernetwork(**args) # create empty embedding # pylint: disable=E1111 shared.state.end() - return CreateResponse(info = "create hypernetwork filename: {filename}".format(filename = filename)) + return CreateResponse(info = f"create hypernetwork filename: {filename}") except AssertionError as e: shared.state.end() - return TrainResponse(info = "create hypernetwork error: {error}".format(error = e)) + return TrainResponse(info = f"create hypernetwork error: {e}") def preprocess(self, args: dict): try: @@ -535,13 +498,13 @@ class Api: return PreprocessResponse(info = 'preprocess complete') except KeyError as e: shared.state.end() - return PreprocessResponse(info = "preprocess error: invalid token: {error}".format(error = e)) + return PreprocessResponse(info = f"preprocess error: invalid token: {e}") except AssertionError as e: shared.state.end() - return PreprocessResponse(info = "preprocess error: {error}".format(error = e)) + return PreprocessResponse(info = f"preprocess error: {e}") except FileNotFoundError as e: shared.state.end() - return PreprocessResponse(info = 'preprocess error: {error}'.format(error = e)) + return PreprocessResponse(info = f'preprocess error: {e}') def train_embedding(self, args: dict): try: @@ -552,17 +515,17 @@ class Api: if not apply_optimizations: sd_hijack.undo_optimizations() try: - embedding, filename = train_embedding(**args) # can take a long time to complete + _embedding, filename = train_embedding(**args) # can take a long time to complete except Exception as e: error = e finally: if not apply_optimizations: sd_hijack.apply_optimizations() shared.state.end() - return TrainResponse(info = "train embedding complete: filename: {filename} error: {error}".format(filename = filename, error = error)) + return TrainResponse(info = f"train embedding complete: filename: {filename} error: {error}") except AssertionError as msg: shared.state.end() - return TrainResponse(info = "train embedding error: {msg}".format(msg = msg)) + return TrainResponse(info = f"train embedding error: {msg}") def train_hypernetwork(self, args: dict): try: @@ -574,7 +537,7 @@ class Api: if not apply_optimizations: sd_hijack.undo_optimizations() try: - hypernetwork, filename = train_hypernetwork(**args) + _hypernetwork, filename = train_hypernetwork(**args) except Exception as e: error = e finally: @@ -583,10 +546,10 @@ class Api: if not apply_optimizations: sd_hijack.apply_optimizations() shared.state.end() - return TrainResponse(info="train embedding complete: filename: {filename} error: {error}".format(filename=filename, error=error)) - except AssertionError as msg: + return TrainResponse(info=f"train embedding complete: filename: {filename} error: {error}") + except AssertionError: shared.state.end() - return TrainResponse(info="train embedding error: {error}".format(error=error)) + return TrainResponse(info=f"train embedding error: {error}") def shutdown(self): print('shutdown request received') @@ -600,7 +563,8 @@ class Api: def get_memory(self): try: - import os, psutil + import os + import psutil process = psutil.Process(os.getpid()) res = process.memory_info() # only rss is cross-platform guaranteed so we dont rely on other values ram_total = 100 * res.rss / process.memory_percent() # and total memory is calculated as actual value is not cross-platform safe diff --git a/modules/api/models.py b/modules/api/models.py index 4a70f440c..21d2c2663 100644 --- a/modules/api/models.py +++ b/modules/api/models.py @@ -1,11 +1,10 @@ import inspect -from pydantic import BaseModel, Field, create_model -from typing import Any, Optional +from typing import Any, Optional, Dict, List +from pydantic import BaseModel, Field, create_model # pylint: disable=no-name-in-module from typing_extensions import Literal from inflection import underscore from modules.processing import StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img from modules.shared import sd_upscalers, opts, parser -from typing import Dict, List API_NOT_ALLOWED = [ "self", @@ -14,8 +13,6 @@ API_NOT_ALLOWED = [ "outpath_samples", "outpath_grids", "sampler_index", - # "do_not_save_samples", - # "do_not_save_grid", "extra_generation_params", "overlay_images", "do_not_reload_embeddings", @@ -48,7 +45,7 @@ class PydanticModelGenerator: class_instance = None, additional_fields = None, ): - def field_type_generator(k, v): + def field_type_generator(_k, v): # field_type = str if not overrides.get(k) else overrides[k]["type"] # print(k, v.annotation, v.default) field_type = v.annotation @@ -76,23 +73,21 @@ class PydanticModelGenerator: for (k,v) in self._class_data.items() if k not in API_NOT_ALLOWED ] - for fields in additional_fields: + for fld in additional_fields: self._model_def.append(ModelDef( - field=underscore(fields["key"]), - field_alias=fields["key"], - field_type=fields["type"], - field_value=fields["default"], - field_exclude=fields["exclude"] if "exclude" in fields else False)) + field=underscore(fld["key"]), + field_alias=fld["key"], + field_type=fld["type"], + field_value=fld["default"], + field_exclude=fld["exclude"] if "exclude" in fld else False)) def generate_model(self): """ Creates a pydantic BaseModel from the json and overrides provided at initialization """ - fields = { - d.field: (d.field_type, Field(default=d.field_value, alias=d.field_alias, exclude=d.field_exclude)) for d in self._model_def - } - DynamicModel = create_model(self._model_name, **fields) + model_fields = { d.field: (d.field_type, Field(default=d.field_value, alias=d.field_alias, exclude=d.field_exclude)) for d in self._model_def } + DynamicModel = create_model(self._model_name, **model_fields) DynamicModel.__config__.allow_population_by_field_name = True DynamicModel.__config__.allow_mutation = True return DynamicModel @@ -209,7 +204,7 @@ for key, metadata in opts.data_labels.items(): value = opts.data.get(key) optType = opts.typemap.get(type(metadata.default), type(value)) - if (metadata is not None): + if metadata is not None: fields.update({key: (Optional[optType], Field( default=metadata.default ,description=metadata.label))}) else: @@ -220,10 +215,11 @@ OptionsModel = create_model("Options", **fields) flags = {} _options = vars(parser)['_option_string_actions'] for key in _options: - if(_options[key].dest != 'help'): + if _options[key].dest != 'help': flag = _options[key] _type = str - if _options[key].default is not None: _type = type(_options[key].default) + if _options[key].default is not None: + _type = type(_options[key].default) flags.update({flag.dest: (_type,Field(default=flag.default, description=flag.help))}) FlagsModel = create_model("Flags", **flags) @@ -288,4 +284,4 @@ class MemoryResponse(BaseModel): class ScriptsList(BaseModel): txt2img: list = Field(default=None,title="Txt2img", description="Titles of scripts (txt2img)") - img2img: list = Field(default=None,title="Img2img", description="Titles of scripts (img2img)") \ No newline at end of file + img2img: list = Field(default=None,title="Img2img", description="Titles of scripts (img2img)") diff --git a/modules/cmd_args.py b/modules/cmd_args.py index 692f6451f..a8f20ca58 100644 --- a/modules/cmd_args.py +++ b/modules/cmd_args.py @@ -2,7 +2,7 @@ import argparse import os from modules.paths_internal import data_path, sd_default_config, sd_model_file -parser = argparse.ArgumentParser(description="Stable Diffusion", formatter_class=lambda prog: argparse.HelpFormatter(prog,max_help_position=55,indent_increment=2,width=200)) +parser = argparse.ArgumentParser(description="Stable Diffusion", conflict_handler='resolve', formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=55, indent_increment=2, width=200)) parser.add_argument("-f", action='store_true', help=argparse.SUPPRESS) # allows running as root; implemented outside of webui parser.add_argument("--ui-settings-file", type=str, help=argparse.SUPPRESS, default=os.path.join(data_path, 'config.json')) diff --git a/modules/img2img.py b/modules/img2img.py index 302ae61ec..4a3472d27 100644 --- a/modules/img2img.py +++ b/modules/img2img.py @@ -151,7 +151,7 @@ def img2img(id_task: str, mode: int, prompt: str, negative_prompt: str, prompt_s ) p.scripts = modules.scripts.scripts_img2img - p.script_args = args + # p.script_args = args if mask: p.extra_generation_params["Mask blur"] = mask_blur diff --git a/modules/processing.py b/modules/processing.py index 1c6c36d32..ce2d9f86e 100644 --- a/modules/processing.py +++ b/modules/processing.py @@ -161,6 +161,7 @@ class StableDiffusionProcessing: self.seed_resize_from_w = 0 self.scripts = None self.script_args = script_args + self.per_script_args = {} self.all_prompts = None self.all_negative_prompts = None self.all_seeds = None diff --git a/modules/scripts.py b/modules/scripts.py index 55418dc5b..f08adbb64 100644 --- a/modules/scripts.py +++ b/modules/scripts.py @@ -345,56 +345,56 @@ class ScriptRunner: script = self.selectable_scripts[script_index-1] if script is None: return None - script_args = args[script.args_from:script.args_to] - processed = script.run(p, *script_args) + args = p.per_script_args.get(script.title(), p.script_args[script.args_from:script.args_to]) + processed = script.run(p, *args) shared.total_tqdm.clear() return processed def process(self, p, **kwargs): for script in self.alwayson_scripts: try: - script_args = p.script_args[script.args_from:script.args_to] - script.process(p, *script_args, **kwargs) + args = p.per_script_args.get(script.title(), p.script_args[script.args_from:script.args_to]) + script.process(p, *args, **kwargs) except Exception as e: errors.display(e, f'Running script process: {script.filename}') def before_process_batch(self, p, **kwargs): for script in self.alwayson_scripts: try: - script_args = p.script_args[script.args_from:script.args_to] - script.before_process_batch(p, *script_args, **kwargs) + args = p.per_script_args.get(script.title(), p.script_args[script.args_from:script.args_to]) + script.before_process_batch(p, *args, **kwargs) except Exception as e: errors.display(e, f'Running script before process batch: {script.filename}') def process_batch(self, p, **kwargs): for script in self.alwayson_scripts: try: - script_args = p.script_args[script.args_from:script.args_to] - script.process_batch(p, *script_args, **kwargs) + args = p.per_script_args.get(script.title(), p.script_args[script.args_from:script.args_to]) + script.process_batch(p, *args, **kwargs) except Exception as e: errors.display(e, f'Running script process batch: {script.filename}') def postprocess(self, p, processed): for script in self.alwayson_scripts: try: - script_args = p.script_args[script.args_from:script.args_to] - script.postprocess(p, processed, *script_args) + args = p.per_script_args.get(script.title(), p.script_args[script.args_from:script.args_to]) + script.postprocess(p, processed, *args) except Exception as e: errors.display(e, f'Running script postprocess: {script.filename}') def postprocess_batch(self, p, images, **kwargs): for script in self.alwayson_scripts: try: - script_args = p.script_args[script.args_from:script.args_to] - script.postprocess_batch(p, *script_args, images=images, **kwargs) + args = p.per_script_args.get(script.title(), p.script_args[script.args_from:script.args_to]) + script.postprocess_batch(p, *args, images=images, **kwargs) except Exception as e: errors.display(e, f'Running script before postprocess batch: {script.filename}') def postprocess_image(self, p, pp: PostprocessImageArgs): for script in self.alwayson_scripts: try: - script_args = p.script_args[script.args_from:script.args_to] - script.postprocess_image(p, pp, *script_args) + args = p.per_script_args.get(script.title(), p.script_args[script.args_from:script.args_to]) + script.postprocess_image(p, pp, *args) except Exception as e: errors.display(e, f'Running script postprocess image: {script.filename}') diff --git a/modules/txt2img.py b/modules/txt2img.py index 2fcb4c49d..dffe6d117 100644 --- a/modules/txt2img.py +++ b/modules/txt2img.py @@ -41,7 +41,7 @@ def txt2img(id_task: str, prompt: str, negative_prompt: str, prompt_styles, step override_settings=override_settings, ) p.scripts = modules.scripts.scripts_txt2img - p.script_args = args + # p.script_args = args processed = modules.scripts.scripts_txt2img.run(p, *args) if processed is None: processed = process_images(p) diff --git a/setup.py b/setup.py index 3963832dd..804ee35b0 100644 --- a/setup.py +++ b/setup.py @@ -10,7 +10,7 @@ try: from modules.cmd_args import parser except: import argparse - parser = argparse.ArgumentParser(description="Stable Diffusion", formatter_class=lambda prog: argparse.HelpFormatter(prog,max_help_position=55,indent_increment=2,width=200)) + parser = argparse.ArgumentParser(description="Stable Diffusion", conflict_handler='resolve', formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=55, indent_increment=2, width=200)) class Dot(dict): # dot notation access to dictionary attributes