Upload 6 files

MagicPrompt.txt

@@ -0,0 +1,36 @@
+from transformers import pipeline, set_seed
+import gradio as gr, random, re
+
+
+
+
+def MagicPromptSD(current_MagicPrompt, starting_text):
+    gpt2_pipe = pipeline('text-generation', model=current_MagicPrompt, tokenizer='gpt2')
+    with open("ideas.txt", "r") as f:
+        line = f.readlines()
+
+    for count in range(4):
+        seed = random.randint(100, 1000000)
+        set_seed(seed)
+
+        if starting_text == "":
+            starting_text: str = line[random.randrange(0, len(line))].replace("\n", "").lower().capitalize()
+            starting_text: str = re.sub(r"[,:\-–.!;?_]", '', starting_text)
+            print(starting_text)
+    
+        response = gpt2_pipe(starting_text, max_length=random.randint(60, 90), num_return_sequences=4)
+        response_list = []
+        for x in response:
+            resp = x['generated_text'].strip()
+            if resp != starting_text and len(resp) > (len(starting_text) + 4) and resp.endswith((":", "-", "—")) is False:
+                response_list.append(resp+'\n')
+    
+        response_end = "\n".join(response_list)
+        response_end = re.sub('[^ ]+\.[^ ]+','', response_end)
+        response_end = response_end.replace("<", "").replace(">", "")
+
+        if response_end != "":
+            return response_end
+        if count == 4:
+            return response_end
+

Upscaler.txt

@@ -0,0 +1,8 @@
+import gradio as gr
+import cv2
+import numpy as np
+
+def upscale_image(input_image, radio_input):
+    upscale_factor = radio_input
+    output_image = cv2.resize(input_image, None, fx = upscale_factor, fy = upscale_factor, interpolation = cv2.INTER_CUBIC)
+    return output_image

app.txt

@@ -0,0 +1,343 @@
+"""
+This is NEW release of DreamDrop V2.0!
+
+Features added:
+    1. Can generate up to 10 images at a time
+    2. Image Upscaler (x8) appeared
+    3. Integrated MagicPrompt (for Stable Diffusion and for Dall•E)
+    4. Added generation parameters menu (Steps, Samplers and CFG Sсale)
+
+Enjoy!
+"""
+
+
+import numpy as np
+import gradio as gr
+import requests
+import time
+import json
+import base64
+import os
+from io import BytesIO
+import PIL
+from PIL.ExifTags import TAGS
+import html
+import re
+
+from MagicPrompt import MagicPromptSD
+from Upscaler import upscale_image
+
+batch_count = 1
+batch_size = 1
+
+i2i_batch_count = 1
+i2i_batch_size = 1
+
+class Prodia:
+    def __init__(self, api_key, base=None):
+        self.base = base or "https://api.prodia.com/v1"
+        self.headers = {
+            "X-Prodia-Key": api_key
+        }
+    
+    def generate(self, params):
+        response = self._post(f"{self.base}/sd/generate", params)
+        return response.json()
+    
+    def transform(self, params):
+        response = self._post(f"{self.base}/sd/transform", params)
+        return response.json()
+    
+    def controlnet(self, params):
+        response = self._post(f"{self.base}/sd/controlnet", params)
+        return response.json()
+    
+    def get_job(self, job_id):
+        response = self._get(f"{self.base}/job/{job_id}")
+        return response.json()
+
+    def wait(self, job):
+        job_result = job
+
+        while job_result['status'] not in ['succeeded', 'failed']:
+            time.sleep(0.25)
+            job_result = self.get_job(job['job'])
+
+        return job_result
+
+    def list_models(self):
+        response = self._get(f"{self.base}/sd/models")
+        return response.json()
+
+    def list_samplers(self):
+        response = self._get(f"{self.base}/sd/samplers")
+        return response.json()
+
+    def _post(self, url, params):
+        headers = {
+            **self.headers,
+            "Content-Type": "application/json"
+        }
+        response = requests.post(url, headers=headers, data=json.dumps(params))
+
+        if response.status_code != 200:
+            raise Exception(f"Bad Prodia Response: {response.status_code}")
+
+        return response
+
+    def _get(self, url):
+        response = requests.get(url, headers=self.headers)
+
+        if response.status_code != 200:
+            raise Exception(f"Bad Prodia Response: {response.status_code}")
+
+        return response
+
+
+def image_to_base64(image):
+    # Convert the image to bytes
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")  # You can change format to PNG if needed
+    
+    # Encode the bytes to base64
+    img_str = base64.b64encode(buffered.getvalue())
+
+    return img_str.decode('utf-8')  # Convert bytes to string
+
+def remove_id_and_ext(text):
+    text = re.sub(r'\[.*\]$', '', text)
+    extension = text[-12:].strip()
+    if extension == "safetensors":
+        text = text[:-13]
+    elif extension == "ckpt":
+        text = text[:-4]
+    return text
+
+def get_data(text):
+    results = {}
+    patterns = {
+        'prompt': r'(.*)',
+        'negative_prompt': r'Negative prompt: (.*)',
+        'steps': r'Steps: (\d+),',
+        'seed': r'Seed: (\d+),',
+        'sampler': r'Sampler:\s*([^\s,]+(?:\s+[^\s,]+)*)', 
+        'model': r'Model:\s*([^\s,]+)',
+        'cfg_scale': r'CFG scale:\s*([\d\.]+)',
+        'size': r'Size:\s*([0-9]+x[0-9]+)'
+        }
+    for key in ['prompt', 'negative_prompt', 'steps', 'seed', 'sampler', 'model', 'cfg_scale', 'size']:
+        match = re.search(patterns[key], text)
+        if match:
+            results[key] = match.group(1)
+        else:
+            results[key] = None
+    if results['size'] is not None:
+        w, h = results['size'].split("x")
+        results['w'] = w
+        results['h'] = h
+    else:
+        results['w'] = None
+        results['h'] = None
+    return results
+
+def send_to_txt2img(image):
+    
+    result = {tabs: gr.Tabs.update(selected="t2i")}
+
+    try:
+        text = image.info['parameters']
+        data = get_data(text)
+        result[prompt] = gr.update(value=data['prompt'])
+        result[negative_prompt] = gr.update(value=data['negative_prompt']) if data['negative_prompt'] is not None else gr.update()
+        result[steps] = gr.update(value=int(data['steps'])) if data['steps'] is not None else gr.update()
+        result[seed] = gr.update(value=int(data['seed'])) if data['seed'] is not None else gr.update()
+        result[cfg_scale] = gr.update(value=float(data['cfg_scale'])) if data['cfg_scale'] is not None else gr.update()
+        result[width] = gr.update(value=int(data['w'])) if data['w'] is not None else gr.update()
+        result[height] = gr.update(value=int(data['h'])) if data['h'] is not None else gr.update()
+        result[sampler] = gr.update(value=data['sampler']) if data['sampler'] is not None else gr.update()
+        if model in model_names:
+            result[model] = gr.update(value=model_names[model])
+        else:
+            result[model] = gr.update()
+        return result
+
+    except Exception as e:
+        print(e)
+        result[prompt] = gr.update()
+        result[negative_prompt] = gr.update()
+        result[steps] = gr.update()
+        result[seed] = gr.update()
+        result[cfg_scale] = gr.update()
+        result[width] = gr.update()
+        result[height] = gr.update()
+        result[sampler] = gr.update()
+        result[model] = gr.update()
+
+        return result
+
+
+prodia_client = Prodia(api_key=os.environ.get("API_X_KEY")) # You can get the API key on https://docs.prodia.com/reference/getting-started-guide
+model_list = prodia_client.list_models()
+model_names = {}
+
+for model_name in model_list:
+    name_without_ext = remove_id_and_ext(model_name)
+    model_names[name_without_ext] = model_name
+
+def txt2img(prompt, negative_prompt, model, sampler, steps, cfg_scale, width, height, num_images):
+    generated_images = []
+    for _ in range(num_images):
+        result = prodia_client.generate({
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "model": model,
+            "steps": steps,
+            "sampler": sampler,
+            "cfg_scale": cfg_scale,
+            "width": width,
+            "height": height,
+            "seed": -1
+        })
+
+        job = prodia_client.wait(result)
+        generated_images.append(job["imageUrl"])
+
+    return generated_images
+
+
+
+def img2img(input_image, denoising, prompt, negative_prompt, model, sampler, steps, cfg_scale, i2i_width, i2i_height):
+    result = prodia_client.transform({
+        "imageData": image_to_base64(input_image),
+        "denoising_strength": denoising,
+        "prompt": prompt,
+        "negative_prompt": negative_prompt,
+        "model": i2i_model.value,
+        "steps": steps,
+        "sampler": sampler,
+        "cfg_scale": cfg_scale,
+        "width": i2i_width,
+        "height": i2i_height,
+        "seed": -1
+    })
+
+    job = prodia_client.wait(result)
+
+    return job["imageUrl"]
+
+
+
+with gr.Blocks(css="style.css", theme="zenafey/prodia-web") as demo:
+    gr.Markdown("""
+    # 🥏 DreamDrop ```V2.0```
+    """)
+    with gr.Tabs() as tabs:
+        with gr.Tab("Text-to-Image", id='t2i'):
+            with gr.Row():
+                with gr.Column(scale=6, min_width=600):
+                    prompt = gr.Textbox(label="Prompt", placeholder="a cute cat, 8k", lines=2)
+                    negative_prompt = gr.Textbox(label="Negative Prompt", value="text, blurry, fuzziness", lines=1)
+                    text_button = gr.Button("Generate", variant='primary')
+                    
+            with gr.Row():
+                with gr.Column(scale=5):
+                    images_output = gr.Gallery(label="Result Image(s)", num_rows=1, num_cols=5, scale=1, allow_preview=True, preview=True)
+            with gr.Row():
+                with gr.Accordion("⚙️ Settings", open=False):
+                    with gr.Column(scale=1):
+                        model = gr.Dropdown(interactive=True, value="absolutereality_v181.safetensors [3d9d4d2b]",
+                                            show_label=True, label="Model",
+                                            choices=prodia_client.list_models())
+                    with gr.Column(scale=1):
+                        sampler = gr.Dropdown(label="Sampler", choices=prodia_client.list_samplers(), value="DPM++ SDE", interactive=True)
+                        steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=25, interactive=True)
+                        cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=20, value=7, interactive=True)
+                        width = gr.Slider(label="↔️ Width", maximum=1024, value=768, step=8)
+                        height = gr.Slider(label="↕️ Height", maximum=1024, value=768, step=8)
+                        num_images = gr.Slider(minimum=1, maximum=10, value=1, step=1, label="Image Count", interactive=True)
+                    
+            text_button.click(txt2img, inputs=[prompt, negative_prompt, model, sampler, steps, cfg_scale, width, height, num_images], outputs=images_output)
+        
+        with gr.Tab("Image-to-Image", id='i2i'):
+            with gr.Row():
+                with gr.Column(scale=6):
+                    with gr.Column(scale=1):
+                        i2i_image_input = gr.Image(label="Input Image", type="pil", interactive=True)
+                with gr.Column(scale=6, min_width=600):
+                    i2i_prompt = gr.Textbox(label="Prompt", placeholder="a cute cat, 8k", lines=2)
+                    i2i_negative_prompt = gr.Textbox(label="Negative Prompt", lines=1, value="text, blurry, fuzziness")
+                with gr.Column():
+                    i2i_text_button = gr.Button("Generate", variant='primary', elem_id="generate")
+                    
+                with gr.Column(scale=1):
+                    i2i_image_output = gr.Image(label="Result Image(s)")
+            with gr.Row():
+                with gr.Accordion("⚙️ Settings", open=False):
+                    with gr.Column(scale=1):
+                        i2i_model = gr.Dropdown(interactive=True,
+                                                value="absolutereality_v181.safetensors [3d9d4d2b]",
+                                                show_label=True, label="Model",
+                                                choices=prodia_client.list_models())
+
+                    with gr.Column(scale=1):
+                        i2i_denoising = gr.Slider(label="Denoising Strength", minimum=0, maximum=1, value=0.7, step=0.1)
+                        sampler = gr.Dropdown(label="Sampler", choices=prodia_client.list_samplers(), value="DPM++ SDE", interactive=True)
+                        steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=25, interactive=True)
+                        cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=20, value=7, interactive=True)
+                        i2i_width = gr.Slider(label="↔️ Width", maximum=1024, value=768, step=8)
+                        i2i_height = gr.Slider(label="↕️ Height", maximum=1024, value=768, step=8)
+
+            i2i_text_button.click(img2img, inputs=[i2i_image_input, i2i_denoising, i2i_prompt, i2i_negative_prompt, model, sampler, steps, cfg_scale, i2i_width, i2i_height], outputs=i2i_image_output)
+        
+        with gr.Tab("Upscaler"):
+            gr.Markdown("""
+            # Upscaler ```x8```
+            """)
+            radio_input = gr.Radio(label="Upscale Levels", choices=[2, 4, 6, 8], value=2)
+            gr.Interface(fn=upscale_image, inputs = [gr.Image(label="Input Image", interactive=True), radio_input], outputs = gr.Image(label="Upscaled Image"))
+            
+        with gr.Tab("PNG-Info"):
+            def plaintext_to_html(text, classname=None):
+                content = "<br>\n".join(html.escape(x) for x in text.split('\n'))
+    
+                return f"<p class='{classname}'>{content}</p>" if classname else f"<p>{content}</p>"
+    
+    
+            def get_exif_data(image):
+                items = image.info
+    
+                info = ''
+                for key, text in items.items():
+                    info += f"""
+                    <div>
+                    <p><b>{plaintext_to_html(str(key))}</b></p>
+                    <p>{plaintext_to_html(str(text))}</p>
+                    </div>
+                    """.strip()+"\n"
+    
+                if len(info) == 0:
+                    message = "Nothing found in the image."
+                    info = f"<div><p>{message}<p></div>"
+    
+                return info
+    
+            with gr.Row():
+                gr.Markdown("""
+                # PNG-Info
+                """)           
+                with gr.Column():
+                    image_input = gr.Image(type="pil", label="Input Image", interactive=True)
+                    
+                with gr.Column():
+                    exif_output = gr.HTML(label="EXIF Data")
+    
+            image_input.upload(get_exif_data, inputs=[image_input], outputs=exif_output)
+
+        
+        with gr.Tab("MagicPrompt"):
+            gr.Markdown("""
+            # MagicPrompt
+            """)
+            gr.Interface(fn=MagicPromptSD, inputs=[gr.Radio(label="Prompt Model", choices=["Gustavosta/MagicPrompt-Stable-Diffusion", "Gustavosta/MagicPrompt-Dalle"], value="Gustavosta/MagicPrompt-Stable-Diffusion"), gr.Textbox(label="Enter your idea")], outputs=gr.Textbox(label="Output Prompt", interactive=False), allow_flagging='never')
+
+demo.launch(show_api=False)

requirements.txt

@@ -0,0 +1,11 @@
+numpy
+gradio
+requests
+pillow
+pyexif
+jinja2==3.1.2
+transformers==4.22.2
+sentencepiece
+torch
+opencv-python
+rembg

style.txt

@@ -0,0 +1,16 @@
+h1 {
+  text-align: center;
+}
+
+#duplicate-button {
+  margin: auto;
+  color: white;
+  background: #1565c0;
+  border-radius: 100vh;
+}
+
+#component-0 {
+  max-width: 900px;
+  margin: auto;
+  padding-top: 1.5rem;
+}