Guided Stable Diffusion: TextToImage Template on Python SDK

import base64

from octoai.client import Client
from octoai.types import Image

# Verify the URLs by checking the QuickStart templates prior to running these examples
sd_health_check = "https://stable-diffusion-demo-kk0powt97tmb.octoai.run/healthcheck"
canny_health_check = "https://controlnet-canny-demo-kk0powt97tmb.octoai.run/healthcheck"
stable_diffusion_url = "https://stable-diffusion-demo-kk0powt97tmb.octoai.run/predict"
canny_url = "https://controlnet-canny-demo-kk0powt97tmb.octoai.run/predict"  

OCTOAI_API_TOKEN = "API Token goes here from guide on creating OctoAI API token"
# The client will also identify if OCTOAI_TOKEN is set as an environment variable
client = Client(token=OCTOAI_API_TOKEN)

def stable_diffusion_poodle() -> base64:
    """ This method will create and save an image of a realistic poodle.
    return: Image of a poodle
    rtype: base64
    """
    # By checking the QuickStart templates, we see the inputs Stable Diffusion accepts.
    sd_inputs = {
        "prompt": "A high-quality, realistic photograph of a a poodle",
        "negative_prompt": "Blurry photo, distortion, low-res, bad quality",
        "guidance_scale": 7.5,
        "num_inference_steps": 40,
        "scheduler": "DPMSolverMultistep"
    }
    # First, let's make sure the endpoint is available for inferences.
    if client.health_check(sd_health_check) != 200:
        return
    # Stable Diffusion, as a TextToImage model, returns an image in base64.
    sd_image_base64 = client.infer(endpoint_url=stable_diffusion_url, inputs=sd_inputs).get("image_0")
    # Saves the image.
    Image.from_base64(sd_image_base64).to_file("sd_poodle.png")
    return sd_image_base64
  

def canny_poodle(image: base64) -> base64:
    """This method uses an image to generate a modified image such as changing the background.

    image: Image canny uses as a base, in this case a poodle
    type: base64
    return: Modified image
    rtype: base64
    """

    canny_inputs = {
      	# "image" and "prompt" are both required fields for Canny.
        "image": image,  # Our base64 image from Stable Diffusion
        "prompt": "A high-quality photograph of a poodle dog.  In the background are snow-covered mountains.",
        "num_steps": 10  # Number of de-noising steps, 1-500, optional
    }
    # Let's make sure the canny endpoint is healthy too.
    if client.health_check(canny_health_check) != 200:
        return
    # Canny returns a dictionary with the prediction time and an array of images in base64.
    canny_response = client.infer(endpoint_url=canny_url, inputs=canny_inputs)
    # In the "images" array, the 0 index shows the edges used as a guide.
    # Index 1-3 contains different levels of processed images with later indices being more processed.
    canny_image_base64 = canny_response.get("images")[1]
    # Our Image library can easily save to a file.
    Image.from_base64(canny_image_base64).to_file("canny_poodle.jpeg")
    return canny_image_base64
  
# Let's run it!
sd_poodle = stable_diffusion_poodle()
canny_poodle(sd_poodle)

from octoai.client import Client
from octoai.types import Image

client = Client()  # Your API token can be set in the client if not an environment variable.
# We can use our types module to easily load a file in as a base_64 string
image = Image.from_file("luxury_apartment.png").image_b64

# Please verify the URLs on the demo page for MLSD
mlsd_url = "https://controlnet-mlsd-demo-kk0powt97tmb.octoai.run/predict"
mlsd_health_check = "https://controlnet-mlsd-demo-kk0powt97tmb.octoai.run/healthcheck"

mlsd_inputs = {
  # "image" and "prompt" are required fields for MLSD
  "image": image,  # Our base64 image from Stable Diffusion
  "prompt": "A realistic photograph a medieval castle interior. The hearth is aflame.  The furniture is made of wood and covered in animal skins.",
  "negative_prompt": "longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality",
  "num_steps": 20,  # Number of de-noising steps, 1-500, optional
  "guidance_scale": 20,  # Classifier-free guidance scale from 0.1-30
}
# Let's make sure the canny endpoint is healthy too.
if client.health_check(mlsd_health_check) == 200:
  # MLSD returns a dictionary with the prediction time and an array of images in base64.
  mlsd_response = client.infer(endpoint_url=mlsd_url, inputs=mlsd_inputs)
  # In the "images" array, the image at index 0 will show you the lines used as a guide.
  # Index 1 contains our generated image.
  mlsd_image_base64 = mlsd_response.get("images")[1]
  # Our Image library can easily save to a file.
  Image.from_base64(mlsd_image_base64).to_file("hearth.jpeg")
  

{
  prediction_time_ms: 2709.765884,
  images: ["0 element is the edge maps used to generate the rest of the images in Base64",
           "1 - 3 elements are base64 images at different stages.",
 }