app.py

import json
import requests
import gradio as gr
import random
import time
import os
import datetime
from datetime import datetime
from PIL import Image
from PIL import ImageOps
from PIL import Image, ImageDraw, ImageFont
from textwrap import wrap
import json
from io import BytesIO

print('for  update')

API_TOKEN = os.getenv("API_TOKEN")
DECODEM_TOKEN=os.getenv("DECODEM_TOKEN")


from huggingface_hub import InferenceApi
inference = InferenceApi("bigscience/bloom",token=API_TOKEN)

headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
url_decodemprompts='https://us-central1-createinsightsproject.cloudfunctions.net/getdecodemprompts'

data={"prompt_type":'ad_text_prompt',"decodem_token":DECODEM_TOKEN}
try:
    r = requests.post(url_decodemprompts, data=json.dumps(data), headers=headers)
except requests.exceptions.ReadTimeout as e:
    print(e)
#print(r.content)

prompt_text=str(r.content, 'UTF-8')
print(prompt_text)
data={"prompt_type":'ad_image_prompt',"decodem_token":DECODEM_TOKEN}
try:
    r = requests.post(url_decodemprompts, data=json.dumps(data), headers=headers)
except requests.exceptions.ReadTimeout as e:
    print(e)
#print(r.content)

prompt_image=str(r.content, 'UTF-8')
print(prompt_image)

ENDPOINT_URL="https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1" # url of your endpoint
#ENDPOINT_URL="https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-1-5" # url of your endpoint
HF_TOKEN=API_TOKEN# token where you deployed your endpoint

def generate_image(prompt_SD:str):
    payload = {"inputs": prompt_SD,}
    headers = {
        "Authorization": f"Bearer {HF_TOKEN}",
        "Content-Type": "application/json",
        "Accept": "image/png" # important to get an image back
    }
    response = requests.post(ENDPOINT_URL, headers=headers, json=payload)
    print(response.content)
    img = Image.open(BytesIO(response.content))

    return img
    
def infer(prompt,
          max_length = 250,
          top_k = 0,
          num_beams = 0,
          no_repeat_ngram_size = 2,
          top_p = 0.9,
          seed=42,
          temperature=0.7,
          greedy_decoding = False,
          return_full_text = False):
    
    print(seed)
    top_k = None if top_k == 0 else top_k
    do_sample = False if num_beams > 0 else not greedy_decoding
    num_beams = None if (greedy_decoding or num_beams == 0) else num_beams
    no_repeat_ngram_size = None if num_beams is None else no_repeat_ngram_size
    top_p = None if num_beams else top_p
    early_stopping = None if num_beams is None else num_beams > 0

    params = {
        "max_new_tokens": max_length,
        "top_k": top_k,
        "top_p": top_p,
        "temperature": temperature,
        "do_sample": do_sample,
        "seed": seed,
        "early_stopping":early_stopping,
        "no_repeat_ngram_size":no_repeat_ngram_size,
        "num_beams":num_beams,
        "return_full_text":return_full_text
    }
    
    s = time.time()
    response = inference(prompt, params=params)
    #print(response)
    proc_time = time.time()-s
    #print(f"Processing time was {proc_time} seconds")
    return response

def getadline(text_inp):
    print(text_inp)
    print(datetime.today().strftime("%d-%m-%Y"))
  
    text = prompt_text+"\nInput:"+text_inp + "\nOutput:"
    resp = infer(text,seed=random.randint(0,100))
    
    generated_text=resp[0]['generated_text']
    result = generated_text.replace(text,'').strip()
    result = result.replace("Output:","")
    parts = result.split("###")
    topic = parts[0].strip()
    topic="\n".join(topic.split('\n'))
    
    response_nsfw = requests.get('https://github.com/coffee-and-fun/google-profanity-words/raw/main/data/list.txt')
    data_nsfw = response_nsfw.text
    nsfwlist=data_nsfw.split('\n')
    nsfwlowerlist=[]
    for each in nsfwlist:
      if each!='':
        nsfwlowerlist.append(each.lower())
    nsfwlowerlist.extend(['bra','gay','lesbian',])
    print(topic)
    foundnsfw=0
    for each_word in nsfwlowerlist:
        if each_word in topic.lower() or each_word in text_inp :
            foundnsfw=1
    if foundnsfw==1:
        topic="Unsafe content found. Please try again with different prompts."
        print(topic)
    return(topic)

def getadvertisement(topic):
    input_keyword=topic
    backdrop=['surrounded by water droplets','in front of a brick wall','in front of a wooden wall','in a white boho style studio','with nature backdrop','with water splash','laying on a wooden table',]
    whichitem=random.randint(0,len(backdrop)-1)
    prompt_SD='product photograph of '+input_keyword+' '+backdrop[whichitem]+prompt_image
    # generate image
    image = generate_image(prompt_SD)
    
    # save to disk
    image.save("generation.png")
    
    
    # Set the font to be used
    req = requests.get("https://github.com/openmaptiles/fonts/raw/master/roboto/Roboto-Regular.ttf")
    
    FONT_USER_INFO = ImageFont.truetype(BytesIO(req.content), 75, encoding="utf-8")
    FONT_TEXT = ImageFont.truetype(BytesIO(req.content), 75, encoding="utf-8")
    TITLE_TEXT = ImageFont.truetype(BytesIO(req.content), 75, encoding="utf-8")
    
    #FONT_USER_INFO = ImageFont.load_default()
    #FONT_TEXT = ImageFont.load_default()
    
    # Image dimensions (pixels)
    WIDTH = 768
    HEIGHT = 768
    # Color scheme
    COLOR_BG = 'white'
    COLOR_NAME = 'black'
    COLOR_TAG = (64, 64, 64)
    COLOR_TEXT = 'black'
    # Write coordinates
    COORD_PHOTO = (10, 40)
    COORD_NAME = (10, 200)
    COORD_TAG = (10, 280)
    COORD_TEXT = (10, 128)
    # Extra space to add in between lines of text
    LINE_MARGIN = 5
    # -----------------------------------------------------------------------------
    
    # Information for the image
    # -----------------------------------------------------------------------------
    text = getadline(input_keyword)
    print(text)
    img_name = "textimage"
    # -----------------------------------------------------------------------------
    
    # Setup of variables and calculations
    # -----------------------------------------------------------------------------
    # Break the text string into smaller strings, each having a maximum of 37\
    # characters (a.k.a. create the lines of text for the image)
    text_string_lines = wrap(text, 10)
    
    # Horizontal position at which to start drawing each line of the tweet body
    x = COORD_TEXT[0]
    
    # Current vertical position of drawing (starts as the first vertical drawing\
    # position of the tweet body)
    y = COORD_TEXT[1]
    
    # Create an Image object to be used as a means of extracting the height needed\
    # to draw each line of text
    temp_img = Image.new('RGB', (0, 0))
    temp_img_draw_interf = ImageDraw.Draw(temp_img)
    
    # List with the height (pixels) needed to draw each line of the tweet body
    # Loop through each line of text, and extract the height needed to draw it,\
    # using our font settings
    line_height = [
        temp_img_draw_interf.textsize(text_string_lines[i], font=FONT_TEXT )[1]
        for i in range(len(text_string_lines))
    ]
    # -----------------------------------------------------------------------------
    
    # Image creation
    # -----------------------------------------------------------------------------
    # Create what will be the final image
    img_final = Image.new('RGB', (WIDTH, HEIGHT), color='white')
    # Create the drawing interface
    draw_interf = ImageDraw.Draw(img_final)
    
    
    # Draw each line of the tweet body. To find the height at which the next\
    # line will be drawn, add the line height of the next line to the current\
    # y position, along with a small margin
    for index, line in enumerate(text_string_lines):
        # Draw a line of text
        draw_interf.text((x, y), line, font=FONT_USER_INFO,  fill=COLOR_TEXT)
        # Increment y to draw the next line at the adequate height
        y += line_height[index] + LINE_MARGIN
    
    # Load the user photo (read-mode). It should be a 250x250 circle 
    #user_photo = Image.open('userprofilepic.png', 'r').convert("RGBA")
    
    # Paste the user photo into the working image. We also use the photo for\
    # its own mask to keep the photo's transparencies
    #img_final.paste(user_photo, COORD_PHOTO, mask=user_photo)
    
    # Finally, save the created image
    img_final.save(f'{img_name}.png')
    # -----------------------------------------------------------------------------
    
    im = Image.open(img_name+".png")
    width_orig, height_orig = im.size
    print(width_orig, height_orig)
    
    im_bar = Image.open("generation.png")
    width_orig_x, height_orig_x = im_bar.size
    print(width_orig_x, height_orig_x)
    
    im_bar = im_bar.resize((int(width_orig / 1), int(height_orig / 1)))
    new_im = Image.new('RGB', (2*im.size[0],1*im_bar.size[1]), (250,250,250))
    
    new_im.paste(im, (0,0))
    new_im.paste(im_bar, (im.size[0],0))
    new_im.save('finalimage.png')
    return 'finalimage.png'


with gr.Blocks() as demo:
    gr.Markdown("<h1><center>Ad for Your Business</center></h1>")
    gr.Markdown(
        """ChatGPT based Insights from <a href="https://www.decodem.ai">Decodem.ai</a> for businesses.\nWhile ChatGPT has multiple use cases we have evolved specific use cases/ templates for businesses \n\n This template provides ideas on how a business can generate Advertisement ideas for a product. Enter a product area to size and get the results. Use examples as a guide. We use a equally powerful AI model bigscience/bloom."""
        )
    textbox = gr.Textbox(placeholder="Enter product name...", lines=1,label='Your product')
    btn = gr.Button("Generate")    
    #output1 = gr.Textbox(lines=2,label='Market Sizing Framework')
    output_image = gr.components.Image(label="Your Advertisement")


    btn.click(getadvertisement,inputs=[textbox], outputs=[output_image])
    examples = gr.Examples(examples=['spectacles','rice cooker','smart watch','coffee mug',],
                           inputs=[textbox])
    

demo.launch()