

"""simple docstring"""





import argparse
import json
import math
import os
import time
import traceback
import zipfile
from collections import Counter

import requests




def   _A  (  UpperCamelCase_     :       List[Any],			UpperCamelCase_     :       List[Any]=None)	->						int:
   '''simple docstring'''


   __lowercase								=						None
   if token is not None:
      __lowercase								=						{"Accept": "application/vnd.github+json", "Authorization": F"""Bearer {token}"""}

   __lowercase								=						F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100"""
   __lowercase								=						requests.get(UpperCamelCase_,			headers=UpperCamelCase_).json()
   __lowercase								=						{}

   try:
      job_links.update({job["name"]: job["html_url"] for job in result["jobs"]})
      __lowercase								=						math.ceil((result["total_count"] - 100) / 100)

      for i in range(UpperCamelCase_):
         __lowercase								=						requests.get(url + F"""&page={i + 2}""",			headers=UpperCamelCase_).json()
         job_links.update({job["name"]: job["html_url"] for job in result["jobs"]})

      return job_links
   except Exception:
      print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""")

   return {}




def   _A  (  UpperCamelCase_     :       Any,			UpperCamelCase_     :       str=None)	->						Tuple:
   '''simple docstring'''


   __lowercase								=						None
   if token is not None:
      __lowercase								=						{"Accept": "application/vnd.github+json", "Authorization": F"""Bearer {token}"""}

   __lowercase								=						F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{worflow_run_id}/artifacts?per_page=100"""
   __lowercase								=						requests.get(UpperCamelCase_,			headers=UpperCamelCase_).json()
   __lowercase								=						{}

   try:
      artifacts.update({artifact["name"]: artifact["archive_download_url"] for artifact in result["artifacts"]})
      __lowercase								=						math.ceil((result["total_count"] - 100) / 100)

      for i in range(UpperCamelCase_):
         __lowercase								=						requests.get(url + F"""&page={i + 2}""",			headers=UpperCamelCase_).json()
         artifacts.update({artifact["name"]: artifact["archive_download_url"] for artifact in result["artifacts"]})

      return artifacts
   except Exception:
      print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""")

   return {}




def   _A  (  UpperCamelCase_     :       int,			UpperCamelCase_     :       Optional[int],			UpperCamelCase_     :       Tuple,			UpperCamelCase_     :       str)	->						str:
   '''simple docstring'''


   __lowercase								=						None
   if token is not None:
      __lowercase								=						{"Accept": "application/vnd.github+json", "Authorization": F"""Bearer {token}"""}

   __lowercase								=						requests.get(UpperCamelCase_,			headers=UpperCamelCase_,			allow_redirects=UpperCamelCase_)
   __lowercase								=						result.headers["Location"]
   __lowercase								=						requests.get(UpperCamelCase_,			allow_redirects=UpperCamelCase_)
   __lowercase								=						os.path.join(UpperCamelCase_,			F"""{artifact_name}.zip""")
   with open(UpperCamelCase_,			"wb") as fp:
      fp.write(response.content)




def   _A  (  UpperCamelCase_     :       List[str],			UpperCamelCase_     :       str=None)	->						List[str]:
   '''simple docstring'''


   __lowercase								=						[]
   __lowercase								=						[]
   __lowercase								=						None

   with zipfile.ZipFile(UpperCamelCase_) as z:
      for filename in z.namelist():
         if not os.path.isdir(UpperCamelCase_):
            # read the file
            if filename in ["failures_line.txt", "summary_short.txt", "job_name.txt"]:
               with z.open(UpperCamelCase_) as f:
                  for line in f:
                     __lowercase								=						line.decode("UTF-8").strip()
                     if filename == "failures_line.txt":
                        try:
                           # `error_line` is the place where `error` occurs
                           __lowercase								=						line[: line.index(": ")]
                           __lowercase								=						line[line.index(": ") + len(": ") :]
                           errors.append([error_line, error])
                        except Exception:
                           # skip un-related lines
                           pass
                     elif filename == "summary_short.txt" and line.startswith("FAILED "):
                        # `test` is the test method that failed
                        __lowercase								=						line[len("FAILED ") :]
                        failed_tests.append(UpperCamelCase_)
                     elif filename == "job_name.txt":
                        __lowercase								=						line

   if len(UpperCamelCase_) != len(UpperCamelCase_):
      raise ValueError(
          F"""`errors` and `failed_tests` should have the same number of elements. Got {len(UpperCamelCase_)} for `errors` """
          F"""and {len(UpperCamelCase_)} for `failed_tests` instead. The test reports in {artifact_zip_path} have some"""
          " problem.")

   __lowercase								=						None
   if job_name and job_links:
      __lowercase								=						job_links.get(UpperCamelCase_,			UpperCamelCase_)

   # A list with elements of the form (line of error, error, failed test)
   __lowercase								=						[x + [y] + [job_link] for x, y in zip(UpperCamelCase_,			UpperCamelCase_)]

   return result




def   _A  (  UpperCamelCase_     :       Dict,			UpperCamelCase_     :       Any=None)	->						Optional[Any]:
   '''simple docstring'''


   __lowercase								=						[]

   __lowercase								=						[os.path.join(UpperCamelCase_,			UpperCamelCase_) for p in os.listdir(UpperCamelCase_) if p.endswith(".zip")]
   for p in paths:
      errors.extend(get_errors_from_single_artifact(UpperCamelCase_,			job_links=UpperCamelCase_))

   return errors




def   _A  (  UpperCamelCase_     :       List[str],			UpperCamelCase_     :       List[Any]=None)	->						Any:
   '''simple docstring'''


   __lowercase								=						Counter()
   counter.update([x[1] for x in logs])
   __lowercase								=						counter.most_common()
   __lowercase								=						{}
   for error, count in counts:
      if error_filter is None or error not in error_filter:
         __lowercase								=						{"count": count, "failed_tests": [(x[2], x[0]) for x in logs if x[1] == error]}

   __lowercase								=						dict(sorted(r.items(),			key=lambda UpperCamelCase_: item[1]["count"],			reverse=UpperCamelCase_))
   return r




def   _A  (  UpperCamelCase_     :       Union[str, Any])	->						Optional[Any]:
   '''simple docstring'''


   __lowercase								=						test.split("::")[0]
   if test.startswith("tests/models/"):
      __lowercase								=						test.split("/")[2]
   else:
      __lowercase								=						None

   return test




def   _A  (  UpperCamelCase_     :       Dict,			UpperCamelCase_     :       int=None)	->						List[Any]:
   '''simple docstring'''


   __lowercase								=						[(x[0], x[1], get_model(x[2])) for x in logs]
   __lowercase								=						[x for x in logs if x[2] is not None]
   __lowercase								=						{x[2] for x in logs}

   __lowercase								=						{}
   for test in tests:
      __lowercase								=						Counter()
      # count by errors in `test`
      counter.update([x[1] for x in logs if x[2] == test])
      __lowercase								=						counter.most_common()
      __lowercase								=						{error: count for error, count in counts if (error_filter is None or error not in error_filter)}
      __lowercase								=						sum(error_counts.values())
      if n_errors > 0:
         __lowercase								=						{"count": n_errors, "errors": error_counts}

   __lowercase								=						dict(sorted(r.items(),			key=lambda UpperCamelCase_: item[1]["count"],			reverse=UpperCamelCase_))
   return r




def   _A  (  UpperCamelCase_     :       Any)	->						int:
   '''simple docstring'''


   __lowercase								=						"| no. | error | status |"
   __lowercase								=						"|-:|:-|:-|"
   __lowercase								=						[header, sep]
   for error in reduced_by_error:
      __lowercase								=						reduced_by_error[error]["count"]
      __lowercase								=						F"""| {count} | {error[:100]} |  |"""
      lines.append(UpperCamelCase_)

   return "\n".join(UpperCamelCase_)




def   _A  (  UpperCamelCase_     :       int)	->						Union[str, Any]:
   '''simple docstring'''


   __lowercase								=						"| model | no. of errors | major error | count |"
   __lowercase								=						"|-:|-:|-:|-:|"
   __lowercase								=						[header, sep]
   for model in reduced_by_model:
      __lowercase								=						reduced_by_model[model]["count"]
      __lowercase		,__lowercase								=						list(reduced_by_model[model]["errors"].items())[0]
      __lowercase								=						F"""| {model} | {count} | {error[:60]} | {_count} |"""
      lines.append(UpperCamelCase_)

   return "\n".join(UpperCamelCase_)


if __name__ == "__main__":
   _a       =							argparse.ArgumentParser()
   # Required parameters
   parser.add_argument('--workflow_run_id', type=str, required=True, help='A GitHub Actions workflow run id.')
   parser.add_argument(
       '--output_dir',
       type=str,
       required=True,
       help='Where to store the downloaded artifacts and other result files.',
   )
   parser.add_argument('--token', default=None, type=str, help='A token that has actions:read permission.')
   _a       =							parser.parse_args()

   os.makedirs(args.output_dir, exist_ok=True)

   _a       =							get_job_links(args.workflow_run_id, token=args.token)
   _a       =							{}
   # To deal with `workflow_call` event, where a job name is the combination of the job names in the caller and callee.
   # For example, `PyTorch 1.11 / Model tests (models/albert, single-gpu)`.
   if _job_links:
      for k, v in _job_links.items():
         # This is how GitHub actions combine job names.
         if " / " in k:
            _a       =							k.find(' / ')
            _a       =							k[index + len(' / ') :]
         _a       =							v
   with open(os.path.join(args.output_dir, 'job_links.json'), 'w', encoding='UTF-8') as fp:
      json.dump(job_links, fp, ensure_ascii=False, indent=4)

   _a       =							get_artifacts_links(args.workflow_run_id, token=args.token)
   with open(os.path.join(args.output_dir, 'artifacts.json'), 'w', encoding='UTF-8') as fp:
      json.dump(artifacts, fp, ensure_ascii=False, indent=4)

   for idx, (name, url) in enumerate(artifacts.items()):
      download_artifact(name, url, args.output_dir, args.token)
      # Be gentle to GitHub
      time.sleep(1)

   _a       =							get_all_errors(args.output_dir, job_links=job_links)

   # `e[1]` is the error
   _a       =							Counter()
   counter.update([e[1] for e in errors])

   # print the top 30 most common test errors
   _a       =							counter.most_common(30)
   for item in most_common:
      print(item)

   with open(os.path.join(args.output_dir, 'errors.json'), 'w', encoding='UTF-8') as fp:
      json.dump(errors, fp, ensure_ascii=False, indent=4)

   _a       =							reduce_by_error(errors)
   _a       =							reduce_by_model(errors)

   _a       =							make_github_table(reduced_by_error)
   _a       =							make_github_table_per_model(reduced_by_model)

   with open(os.path.join(args.output_dir, 'reduced_by_error.txt'), 'w', encoding='UTF-8') as fp:
      fp.write(sa)
   with open(os.path.join(args.output_dir, 'reduced_by_model.txt'), 'w', encoding='UTF-8') as fp:
      fp.write(sa)







"""simple docstring"""





from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


_a       =							'CompVis/stable-diffusion-v1-1'
_a       =							'CompVis/stable-diffusion-v1-2'
_a       =							'CompVis/stable-diffusion-v1-3'
_a       =							'CompVis/stable-diffusion-v1-4'




class 					_lowerCAmelCase  (	lowercase   ):







 """simple docstring"""







 def __init__(			self							:			Dict,					UpperCAmelCase__							:			AutoencoderKL,					UpperCAmelCase__							:			CLIPTextModel,					UpperCAmelCase__							:			CLIPTokenizer,					UpperCAmelCase__							:			UNetaDConditionModel,					UpperCAmelCase__							:			Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler],					UpperCAmelCase__							:			StableDiffusionSafetyChecker,					UpperCAmelCase__							:			CLIPImageProcessor,					UpperCAmelCase__							:			bool = True,					):
    super()._init_()

    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline.from_pretrained(UpperCAmelCase__	)
    __lowercase								=						StableDiffusionPipeline(
        vae=UpperCAmelCase__,					text_encoder=UpperCAmelCase__,					tokenizer=UpperCAmelCase__,					unet=UpperCAmelCase__,					scheduler=UpperCAmelCase__,					safety_checker=UpperCAmelCase__,					feature_extractor=UpperCAmelCase__,					requires_safety_checker=UpperCAmelCase__,					)

    self.register_modules(pipelinea=self.pipea,					pipelinea=self.pipea,					pipelinea=self.pipea,					pipelinea=self.pipea	)


 @property
 def 					_lowercase (			self							:			List[str]	):
    return {k: getattr(self,					UpperCAmelCase__	) for k in self.config.keys() if not k.startswith("_"	)}


 def 					_lowercase (			self							:			Union[str, Any],					UpperCAmelCase__							:			Optional[Union[str, int]] = "auto"	):
    if slice_size == "auto":
       # half the attention head size is usually a good trade-off between
       # speed and memory
       __lowercase								=						self.unet.config.attention_head_dim // 2
    self.unet.set_attention_slice(UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[str]	):
    self.enable_attention_slicing(UpperCAmelCase__	)


 @torch.no_grad()
 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			Tuple,					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)


 @torch.no_grad()
 def 					_lowercase (			self							:			Tuple,					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			str,					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)


 @torch.no_grad()
 def 					_lowercase (			self							:			str,					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			Any,					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)


 @torch.no_grad()
 def 					_lowercase (			self							:			Union[str, Any],					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			Optional[int],					):
    return self.pipea(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)



 @torch.no_grad()
 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Union[str, List[str]],					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_1_2,					UpperCAmelCase__							:			int = 5_0,					UpperCAmelCase__							:			float = 7.5,					UpperCAmelCase__							:			Optional[Union[str, List[str]]] = None,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[torch.FloatTensor] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			Optional[Callable[[int, int, torch.FloatTensor], None]] = None,					UpperCAmelCase__							:			int = 1,					**UpperCAmelCase__							:			str,					):
    __lowercase								=						"cuda" if torch.cuda.is_available() else "cpu"
    self.to(UpperCAmelCase__	)

    # Checks if the height and width are divisible by 8 or not
    if height % 8 != 0 or width % 8 != 0:
       raise ValueError(F"""`height` and `width` must be divisible by 8 but are {height} and {width}."""	)

    # Get first result from Stable Diffusion Checkpoint v1.1
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get first result from Stable Diffusion Checkpoint v1.2
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get first result from Stable Diffusion Checkpoint v1.3
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get first result from Stable Diffusion Checkpoint v1.4
    __lowercase								=						self.textaimg_sda_a(
        prompt=UpperCAmelCase__,					height=UpperCAmelCase__,					width=UpperCAmelCase__,					num_inference_steps=UpperCAmelCase__,					guidance_scale=UpperCAmelCase__,					negative_prompt=UpperCAmelCase__,					num_images_per_prompt=UpperCAmelCase__,					eta=UpperCAmelCase__,					generator=UpperCAmelCase__,					latents=UpperCAmelCase__,					output_type=UpperCAmelCase__,					return_dict=UpperCAmelCase__,					callback=UpperCAmelCase__,					callback_steps=UpperCAmelCase__,					**UpperCAmelCase__,					)

    # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
    return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]	)




