merge hf default + github

LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

README.md

@@ -1,14 +1,16 @@
 ---
-title: Gradio Hf Text2image
-emoji: 🐢
+title: Huggingface Hub Text2Image Inference Client
+emoji: 🖼
 colorFrom: red
 colorTo: pink
 sdk: gradio
-sdk_version: 5.12.0
+sdk_version: 4.42.0
 app_file: app.py
 pinned: false
 license: cc0-1.0
 short_description: A simple text2image serverless interface
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+A simple text2image interface for the Huggingface Hub serverless API,
+supporting extra generation parameters.
+

app.py

@@ -0,0 +1,252 @@
+from collections import OrderedDict
+from pathlib import Path
+from time import perf_counter
+
+import gradio as gr
+from huggingface_hub import (
+    HfApi,
+    InferenceClient,
+)
+
+import config as cfg
+from imagemeta import (
+    get_image_meta_str,
+    add_metadata_to_pil_image,
+    save_image_timestamp,
+)
+
+# XXX find out which schedulers are actually supported
+scheduler_map = {
+    "DDIM": 'DDIMScheduler',
+    "DDPM": 'DDPMScheduler',
+    "DEIS": 'DEISMultistepScheduler',
+    "DPM++ 2M": 'DPMSolverMultistepScheduler',
+    "DPM++ 2S": 'DPMSolverSinglestepScheduler',
+    "DPM++ SDE": 'DPMSolverSDEScheduler',
+    "DPM2 a": 'KDPM2AncestralDiscreteScheduler',
+    "DPM2": 'KDPM2DiscreteScheduler',
+    "Euler EDM": 'EDMEulerScheduler',
+    "Euler a": 'EulerAncestralDiscreteScheduler',
+    "Euler": 'EulerDiscreteScheduler',
+    "Heun": 'HeunDiscreteScheduler',
+    "LCM": 'LCMScheduler',
+    "LMS": 'LMSDiscreteScheduler',
+    "PNDM": 'PNDMScheduler',
+    "TCD": 'TCDScheduler',
+    "UniPC": 'UniPCMultistepScheduler',
+}
+
+
+def components_to_parameters(args, ctrl):
+    params = {}
+    params_mul = {}
+    for (name, value) in zip(ctrl, args):
+        if type(name) is tuple:
+            # (type, num, prop), value ==> {(type, num) : {prop: value} }
+            params_mul.setdefault(name[0:2], {})[name[2]] = value
+        else:
+            params[name] = value
+    # group multiple params according to name
+    # {(type, num) : {prop: value} } ==> {type : {name: {prop: value}}
+    for (type_, num), props in params_mul.items():
+        t = params.setdefault(type_, {})
+        name = props.get('name')
+        if name:
+            p = t.setdefault(name, {})
+            for (prop, value) in props.items():
+                p[prop] = value
+    return params
+
+ctra = OrderedDict()
+ctro = OrderedDict()
+
+# https://huggingface.co/docs/api-inference/detailed_parameters
+# https://huggingface.co/docs/huggingface_hub/package_reference/inference_client
+
+from threading import RLock
+lock = RLock()
+
+def extract_params_inference(params):
+    kwargs = {}
+    save_params = {}
+
+    as_is = ['model', 'prompt', 'negative_prompt', 'num_inference_steps', 'guidance_scale',
+      'width', 'height', 'seed']
+    for k in as_is:
+        v = params.get(k)
+        if v:
+            kwargs[k] = v
+    save_params.update(**kwargs)
+
+    clip_skip = params.get('clip_skip')
+    if clip_skip and clip_skip > 1:
+        save_params['clip_skip'] = clip_skip-1
+        kwargs['clip_skip'] = clip_skip-1
+
+    if 'prompt' not in kwargs:
+        kwargs['prompt'] = ''
+
+    sampler = params.get('sampler')
+    if sampler:
+        scheduler = scheduler_map.get(sampler)
+        if scheduler:
+            kwargs['scheduler'] = scheduler
+            save_params['sampler'] = sampler
+
+    return kwargs, save_params
+
+inference_timeout=300.0
+
+def call_text_to_image_api(params, timeout=inference_timeout, token=None):
+    if cfg.DEBUG: print('call_text_to_image_api:', params)
+    kwargs , save_params = extract_params_inference(params)
+    client = InferenceClient(token=token)
+    if cfg.DEBUG: print('call_text_to_image_api: calling params:', kwargs)
+    result = client.text_to_image(**kwargs)
+    image_format=params.get('image_format', cfg.DEFAULT_IMAGE_FORMAT)
+    if result:
+        add_metadata_to_pil_image(result, save_params)
+        if cfg.AUTOSAVE_DIR:
+            with lock:
+                filename = save_image_timestamp(result, cfg.AUTOSAVE_DIR, format=image_format)
+                if cfg.DEBUG: print('call_text_to_image_api: saved to {}'.format(filename))
+    return [result]
+
+
+def infer_api_fn(progress=gr.Progress(), previouslist=None, *args):
+
+    stime = perf_counter()
+    params = components_to_parameters(args, ctra)
+    model_str = params.get('model')
+    if not model_str or model_str == 'NA':
+        return None
+
+    kwargs = {'timeout':inference_timeout}
+    if cfg.HF_TOKEN_SD:
+        kwargs.update(token=cfg.HF_TOKEN_SD)
+
+    result = call_text_to_image_api(params, **kwargs)
+
+    print('gen_fn returning', result)
+    if previouslist is None: previouslist = []
+    mtime = 'API inference {:.2f}s'.format(perf_counter() - stime)
+    return previouslist + result, mtime
+
+
+def update_inference_models():
+    token = cfg.HF_TOKEN_SD or None
+    client = InferenceClient(token=token)
+    models = client.list_deployed_models()
+    inf_models = models.get('text-to-image', [])
+    user_models = []
+    if token and HfApi:
+        api = HfApi(token=token)
+        whoami = api.whoami()['name']
+        user_models = [m.id for m in api.list_models(author=whoami)]
+    t2i_models = sorted(inf_models+user_models)
+    return gr.Dropdown(choices=t2i_models)
+
+js_random = '() => Math.floor(Math.random()*(2**32))'
+
+num_loras=5
+
+app = gr.Blocks()
+with app:
+    state = gr.State({})
+    gr.Markdown('# Huggingface Hub Inference Client')
+    with gr.Row():
+        with gr.Column():
+            with gr.Row():
+                print(cfg.EDIT_MODELS)
+                if 'edit' in cfg.EDIT_MODELS or 'download' in cfg.EDIT_MODELS:
+                    ctra['model'] = gr.Dropdown(label="Checkpoint", choices=cfg.MODEL_LIST,
+                        value=cfg.MODEL_LIST and cfg.MODEL_LIST[0] or None,
+                        allow_custom_value=True, scale=3)
+                elif len(cfg.MODEL_LIST) > 1:
+                    ctra['model'] = gr.Dropdown(label="Checkpoint", choices=cfg.MODEL_LIST,
+                        value=cfg.MODEL_LIST[0],
+                        allow_custom_value=False, scale=3)
+                else:
+                    ctra['model'] = gr.Textbox(label="Checkpoint", value=cfg.MODEL_LIST[0],
+                        interactive=False, scale=3)
+                if 'download' in cfg.EDIT_MODELS:
+                    ctra_update_infmod = gr.Button("⬇️ Get Model List", scale=1)
+            ctra['prompt'] = gr.Textbox(label="Prompt")
+            ctra['negative_prompt'] = gr.Textbox(label="Negative prompt")
+            with gr.Row():
+                ctra['width'] = gr.Number(label="Width", value=512,
+                  minimum=0, maximum=1024, step=8, precision=0)
+                ctra['height'] = gr.Number(label="Height", value=512,
+                  minimum=0, maximum=1024, step=8, precision=0)
+                ctra['sampler'] = gr.Dropdown(label="Sampler",
+                  choices=sorted(scheduler_map.keys()), value='Euler',
+                  scale=1)
+            with gr.Row():
+                ctra['seed'] = gr.Number(label="Seed", value=42,
+                  minimum=-1, maximum=2**64-1, step=1, precision=0)
+                ctra['num_inference_steps'] = gr.Number(label="Steps",
+                  minimum=0, maximum=50, value=10, step=1, scale=0)
+                ctra['guidance_scale'] = gr.Number(label="CFG Scale",
+                  minimum=0, maximum=10, value=4.0, step=0.1, scale=0)
+                ctra['clip_skip'] = gr.Number(label="CLIP Skip",
+                  minimum=1, maximum=12, value=1, step=1, scale=0)
+            with gr.Row():
+                ctra_randomize_button = gr.Button(value="\U0001F3B2",
+                  elem_classes="toolbutton", scale=0, min_width=80)
+                ctra_gen_infapi = gr.Button("Generate with Inference API", scale=4)
+                ctra_stop_button = gr.Button('Stop', variant='secondary',
+                  interactive=False, scale=1)
+
+        with gr.Column():
+            ctro['gallery'] = gr.Gallery(label="Generated images", show_label=False,
+              #show_fullscreen_button=True,
+              type='pil', format=cfg.DEFAULT_IMAGE_FORMAT,
+              show_download_button=True, show_share_button=False)
+            ctro['times'] = gr.Textbox(show_label=False, label="Timing")
+            ctro['imagemeta'] = gr.Textbox(show_label=False, label="Image Metadata")
+            with gr.Row():
+                discard_image_button = gr.Button("Discard Image", scale=1)
+
+    # XXX no idea if it's the best way
+    selected_image = gr.Image(render=False)
+
+    ctra_inference_event = gr.on(fn=infer_api_fn, triggers=[ctra_gen_infapi.click],
+        inputs=[ctro['gallery']] + list(ctra.values()), outputs=[ctro['gallery'], ctro['times']])
+    ctra_gen_infapi.click(lambda: gr.update(interactive=True), None, ctra_stop_button)
+    ctra_stop_button.click(lambda: gr.update(interactive=False), None, ctra_stop_button,
+         cancels=[ctra_inference_event])
+    ctra_randomize_button.click(None, js=js_random, outputs=ctra['seed'])
+    if 'download' in cfg.EDIT_MODELS:
+        ctra_update_infmod.click(update_inference_models, inputs=[], outputs=ctra['model'])
+
+    def discard_image(state, gallery):
+        toremove = state.get('selected')
+        res = []
+        for image in gallery:
+            if toremove == image[0]:
+                state['selected'] = None
+            else:
+                res.append(image)
+        return res
+    discard_image_button.click(discard_image, inputs=[state, ctro['gallery']], outputs=[ctro['gallery']])
+
+    def on_select(value, evt: gr.SelectData, state):
+        #return f"The {evt.target} component was selected, index {evt.index}, and its value was {value}."
+        res = ''
+        index = evt.index
+        imagelist = value
+        if index >= 0 and index < len(imagelist):
+            image, caption = imagelist[index]
+            res = get_image_meta_str(image)
+            state['selected'] = image
+        else:
+            state['selected'] = None
+        return res
+
+    ctro['gallery'].select(on_select, [ctro['gallery'], state], [ctro['imagemeta']])
+
+if __name__ == '__main__':
+    app.launch(show_error=True, debug=True)
+
+
+

config.py

@@ -0,0 +1,24 @@
+'''app config'''
+import os
+from pathlib import Path
+
+# HF token
+HF_TOKEN_SD = os.environ.get('HF_TOKEN_SD')
+
+# if set, generated images will be saved here
+AUTOSAVE_DIR = os.environ.get('AUTOSAVE_DIR', '')
+
+# 1 enables debug
+DEBUG = os.environ.get('DEBUG')
+
+# default image format (png, jpeg, webp)
+DEFAULT_IMAGE_FORMAT = os.environ.get('DEFAULT_IMAGE_FORMAT', 'png')
+
+# models available at start (comma separated)
+MODEL_LIST = os.environ.get('MODEL_LIST', '').split(',')
+
+# controls the model list editing (comma separated):
+#   download: enable fetching available models
+#   edit: enable editing the field
+EDIT_MODELS = os.environ.get('EDIT_MODELS', '').split(',')
+

imagemeta.py

@@ -0,0 +1,230 @@
+from PIL import Image, ExifTags, PngImagePlugin
+from sd_parsers import ParserManager
+from io import BytesIO
+from pathlib import Path
+from os import path
+import sys
+import time
+from typing import Union
+
+#def format_metadata(params: dict) -> str:
+def format_metadata(params):
+    lines = []
+
+    lines.append(params['prompt'])
+
+    loras = params.get('lora', {})
+    lorainfo=[]
+    for name, props in sorted(loras.items()):
+        weight = props.get('weight')
+        weight = float(weight) if weight else 0.0
+        if name and weight:
+            lorainfo.append('<lora:{}:{}>'.format(name,weight))
+    if lorainfo:
+        lines.append(''.join(lorainfo))
+
+    negative_prompt = params.get('negative_prompt')
+    if negative_prompt is not None:
+        lines.append('Negative prompt: ' + negative_prompt)
+
+    info = []
+
+    info.append(('Steps', params['num_inference_steps']))
+
+    sampler = params.get('sampler')
+    if sampler:
+        info.append(('Sampler', sampler))
+
+    info.append(('CFG Scale', params['guidance_scale']))
+
+    seed = params.get('seed', -1)
+    if seed != -1:
+        info.append(('Seed', seed))
+
+    width, height = params.get('width'), params.get('height')
+    if width and height:
+        info.append(('Size', '{}x{}'.format(width, height)))
+
+    model = params.get('model')
+    if model is not None:
+        if model.endswith('.safetensors'):
+            # filename without extension
+            model = path.basename(model).rsplit('.', 1)[0]
+        # else assume it's a model id
+        info.append(('Model', model))
+
+    mode = params.get('mode') # Img2Img, Txt2Img
+    if mode is not None:
+        info.append(('Mode', mode))
+
+        if mode == 'Img2Img':
+            strength = params.get('strength')
+            if strength is not None:
+                info.append(('Denoising strength', strength))
+
+    clip_skip = params.get('clip_skip', 0)
+    if clip_skip >= 1:
+        info.append(('Clip skip', clip_skip+1))
+
+    controlnet_model = params.get('cnet_model', '')
+    controlnet_conditioning_scale = params.get('controlnet_conditioning_scale', 0.0)
+    if controlnet_model and controlnet_conditioning_scale >= 0.001:
+        info.append(('ControlNet', controlnet_conditioning_scale))
+        info.append(('ControlNet Conditioning Scale', controlnet_conditioning_scale))
+        if params.get('guess_mode'):
+            info.append(('ControlNet Guess Mode', 1))
+
+    vae = params.get('vae')
+    if vae is not None:
+        info.append(('VAE', vae))
+
+    for (opt, meta) in [
+        ('compel', 'Compel'),
+        ('freeu', 'FreeU'),
+        ('resadapter_norm', 'ResAdapter Normalization'),
+        ('vae_tiling', 'VAE Tiling'),
+        ]:
+        if params.get(opt):
+            info.append((meta, 1))
+
+    for (opt, meta) in [
+        ('eta', 'Eta'),
+        ('pag_adaptive_scale', 'PAG Adaptive Scale'),
+        ('pag_scale', 'PAG Scale'),
+        ('sag_scale', 'SAG Scale'),
+        ('token_merging_ratio', 'Token Merging Ratio'),
+        ]:
+        val = params.get(opt, 0.0)
+        if val and val >= 0.01:
+            info.append((meta, val))
+
+    lines.append(', '.join(['{}: {}'.format(k, v) for (k, v) in info]))
+
+    return '\n'.join(lines)
+
+#def add_metadata_to_pil_image(pil_image: Image, params: Union[dict, str])-> None:
+def add_metadata_to_pil_image(pil_image, params):
+    '''add generation parameters to the image info fields, in a Gradio-compatible way'''
+
+    if isinstance(params, str):
+        metadata = params
+    else:
+        metadata = format_metadata(params)
+
+    pil_image.info['parameters'] = metadata
+
+    # borrowed from piexif
+    usercomment = b'UNICODE\0' + metadata.encode('utf_16_be', errors='replace')
+    # The PIL Exif encoder detects both bytes and bytearrays as sequences of
+    # integers, so they get encoded with the wrong type, and most tools won't
+    # interpret that as text. A list wrapping a bytearray dodges those
+    # heuristics, correctly storing the data as a byte sequence.
+    usercomment = [bytearray(usercomment)]
+    exif = pil_image.getexif()
+    exif.setdefault(ExifTags.IFD.Exif, {})[ExifTags.Base.UserComment] = usercomment
+    pil_image.info['exif'] = exif.tobytes()
+
+def get_image_meta_str(image):
+    res = []
+    if image.filename:
+        res.append('Filename: {}'.format(image.filename))
+    if image.format:
+        res.append('Format: {}'.format(image.format))
+    res.append('Size: {}x{}'.format(*image.size))
+    info = ParserManager().parse(image)
+    if info:
+        for prompt in info.prompts:
+            if prompt:
+                res.append('Prompt: {}'.format(prompt))
+        for negative_prompt in info.negative_prompts:
+            if negative_prompt:
+                res.append('Negative Prompt: {}'.format(negative_prompt))
+        for sampler in info.samplers:
+            if sampler.name:
+                res.append('Sampler: {}'.format(sampler.name))
+            seed = sampler.parameters.get('seed')
+            if seed:
+                res.append('Seed: {}'.format(seed))
+            steps = sampler.parameters.get('steps')
+            if steps:
+                res.append('Steps: {}'.format(steps))
+            if sampler.model and sampler.model.name:
+                res.append('Model: {}'.format(sampler.model.name))
+        for (meta, value) in sorted(info.metadata.items()):
+            res.append('{}: {}'.format(meta, value))
+    return '\n'.join(res)
+
+#def extract_meta_for_saving(pil_image: Image):
+def extract_meta_for_saving(pil_image):
+
+    meta_args = {}
+
+    exif = pil_image.info.get('exif')
+    if exif:
+        meta_args["exif"] = exif
+
+    pngtexts = [ (key, value) for key, value in pil_image.info.items()
+        if isinstance(key, str) and isinstance(value, str) ]
+    if pngtexts:
+       pnginfo = PngImagePlugin.PngInfo()
+       for key, value in pngtexts:
+           pnginfo.add_text(key, value)
+       meta_args["pnginfo"] = pnginfo
+
+    return meta_args
+
+def filebytes(pil_image, format):
+    with BytesIO() as output_bytes:
+        meta_params = extract_meta_for_saving(pil_image)
+        if format in ['jpeg', 'jpg', 'webp']:
+            meta_params['quality'] = 90
+        pil_image.save(output_bytes, format=format, **meta_params)
+        return output_bytes.getvalue()
+
+def open_file_timestamp(basename, directory='.', extension='.png'):
+    output = Path(directory)
+    count = 0
+
+    opt = True
+    spbasename = basename.rsplit('-', 1)
+    if len(spbasename) == 2 and len(spbasename[1]) == 4 and spbasename[1].isdigit():
+        count = int(spbasename[1])
+        basename = spbasename[0]
+        opt = False
+
+    def getfilepath(count):
+        extra = '-{:04}'.format(count)
+        return output / '{}{}.{}'.format(basename, extra, extension)
+    filepath = getfilepath(count)
+
+    # otimizacao
+    if opt:
+        existing = sorted(output.glob(basename + '*.' + extension))
+        if existing:
+            count = 1
+            last = existing[-1].name[:len(extension)]
+            sepnum = (last.rsplit('-', 1)+[''])[1]
+            if sepnum.isdigit():
+                count = int(sepnum)
+            filepath = getfilepath(count)
+
+    while True:
+        try:
+            return open(filepath, 'xb')
+        except FileExistsError:
+            count += 1
+            filepath = getfilepath(count)
+
+def save_image_with_meta(pil_image, basename, directory, format="png"):
+    filedata = filebytes(pil_image, format)
+    with open_file_timestamp(basename, directory, format) as outfile:
+        outfile.write(filedata)
+        return outfile.name
+
+
+def save_image_timestamp(pil_image, directory, format="png"):
+    outdir = Path(directory)
+    basename = time.strftime('%Y%m%d-0001')
+    return save_image_with_meta(pil_image, basename, outdir, format)
+
+

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.20.0
+sd-parsers
+