






'''simple docstring'''







from typing import List, Optional, Union

import torch
from transformers import (
    XLMRobertaTokenizer,
)

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDIMScheduler, DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .text_encoder import MultilingualCLIP


A									=logging.get_logger(__name__)  # pylint: disable=invalid-name

A									='\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyPriorPipeline.from_pretrained(\"kandinsky-community/Kandinsky-2-1-prior\")\n        >>> pipe_prior.to(\"cuda\")\n\n        >>> prompt = \"red cat, 4k photo\"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> negative_image_emb = out.negative_image_embeds\n\n        >>> pipe = KandinskyPipeline.from_pretrained(\"kandinsky-community/kandinsky-2-1\")\n        >>> pipe.to(\"cuda\")\n\n        >>> image = pipe(\n        ...     prompt,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=negative_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ... ).images\n\n        >>> image[0].save(\"cat.png\")\n        ```\n'





def 		snake_case_							(_a			:							int					,     _a			:							Any					,     _a			:							Tuple=8  ):
    UpperCAmelCase     =	h // scale_factor**2
    if h % scale_factor**2 != 0:
        new_h += 1
    UpperCAmelCase     =	w // scale_factor**2
    if w % scale_factor**2 != 0:
        new_w += 1
    return new_h * scale_factor, new_w * scale_factor







class     _a						(			__a				):
       def __init__(			self		:			List[Any]     ,       lowercase		:			str     ,       lowercase		:			Optional[int]     ,       lowercase		:			Dict     ,       lowercase		:			int     ,       lowercase		:			int     ,       ):



           '''simple docstring'''

           super().__init__()

           self.register_modules(
               text_encoder=__a     ,       tokenizer=__a     ,       unet=__a     ,       scheduler=__a     ,       movq=__a     ,       )
           UpperCAmelCase     =	2 ** (len(self.movq.config.block_out_channels       ) - 1)
       def 					A   (			self		:			Optional[int]     ,       lowercase		:			Union[str, Any]     ,       lowercase		:			Optional[int]     ,       lowercase		:			int     ,       lowercase		:			Any     ,       lowercase		:			Any     ,       lowercase		:			Any       ):



           '''simple docstring'''

           if latents is None:
               UpperCAmelCase     =	randn_tensor(__a     ,       generator=__a     ,       device=__a     ,       dtype=__a       )
           else:
               if latents.shape != shape:
                   raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}"       )
               UpperCAmelCase     =	latents.to(__a       )

           UpperCAmelCase     =	latents * scheduler.init_noise_sigma
           return latents
       def 					A   (			self		:			List[Any]     ,       lowercase		:			List[Any]     ,       lowercase		:			Union[str, Any]     ,       lowercase		:			Optional[Any]     ,       lowercase		:			Tuple     ,       lowercase		:			int=None     ,       ):



           '''simple docstring'''

           UpperCAmelCase     =	len(__a       ) if isinstance(__a     ,       __a       ) else 1
           # get prompt text embeddings
           UpperCAmelCase     =	self.tokenizer(
               __a     ,       padding='''max_length'''     ,       truncation=__a     ,       max_length=77     ,       return_attention_mask=__a     ,       add_special_tokens=__a     ,       return_tensors='''pt'''     ,       )

           UpperCAmelCase     =	text_inputs.input_ids
           UpperCAmelCase     =	self.tokenizer(__a     ,       padding='''longest'''     ,       return_tensors='''pt'''       ).input_ids

           if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(__a     ,       __a       ):
               UpperCAmelCase     =	self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]       )
               logger.warning(
                   '''The following part of your input was truncated because CLIP can only handle sequences up to'''
                   f" {self.tokenizer.model_max_length} tokens: {removed_text}"       )

           UpperCAmelCase     =	text_input_ids.to(__a       )
           UpperCAmelCase     =	text_inputs.attention_mask.to(__a       )

           UpperCAmelCase ,  UpperCAmelCase     =	self.text_encoder(
               input_ids=__a     ,       attention_mask=__a       )

           UpperCAmelCase     =	prompt_embeds.repeat_interleave(__a     ,       dim=0       )
           UpperCAmelCase     =	text_encoder_hidden_states.repeat_interleave(__a     ,       dim=0       )
           UpperCAmelCase     =	text_mask.repeat_interleave(__a     ,       dim=0       )

           if do_classifier_free_guidance:
               UpperCAmelCase     =	42
               if negative_prompt is None:
                   UpperCAmelCase     =	[''''''] * batch_size
               elif type(__a       ) is not type(__a       ):
                   raise TypeError(
                       f"`negative_prompt` should be the same type to `prompt`, but got {type(__a       )} !="
                       f" {type(__a       )}."       )
               elif isinstance(__a     ,       __a       ):
                   UpperCAmelCase     =	[negative_prompt]
               elif batch_size != len(__a       ):
                   raise ValueError(
                       f"`negative_prompt`: {negative_prompt} has batch size {len(__a       )}, but `prompt`:"
                       f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
                       ''' the batch size of `prompt`.'''       )
               else:
                   UpperCAmelCase     =	negative_prompt

               UpperCAmelCase     =	self.tokenizer(
                   __a     ,       padding='''max_length'''     ,       max_length=77     ,       truncation=__a     ,       return_attention_mask=__a     ,       add_special_tokens=__a     ,       return_tensors='''pt'''     ,       )
               UpperCAmelCase     =	uncond_input.input_ids.to(__a       )
               UpperCAmelCase     =	uncond_input.attention_mask.to(__a       )

               UpperCAmelCase ,  UpperCAmelCase     =	self.text_encoder(
                   input_ids=__a     ,       attention_mask=__a       )

               # duplicate unconditional embeddings for each generation per prompt, using mps friendly method

               UpperCAmelCase     =	negative_prompt_embeds.shape[1]
               UpperCAmelCase     =	negative_prompt_embeds.repeat(1     ,       __a       )
               UpperCAmelCase     =	negative_prompt_embeds.view(batch_size * num_images_per_prompt     ,       __a       )

               UpperCAmelCase     =	uncond_text_encoder_hidden_states.shape[1]
               UpperCAmelCase     =	uncond_text_encoder_hidden_states.repeat(1     ,       __a     ,       1       )
               UpperCAmelCase     =	uncond_text_encoder_hidden_states.view(
                   batch_size * num_images_per_prompt     ,       __a     ,       -1       )
               UpperCAmelCase     =	uncond_text_mask.repeat_interleave(__a     ,       dim=0       )

               # done duplicates

               # For classifier free guidance, we need to do two forward passes.
               # Here we concatenate the unconditional and text embeddings into a single batch
               # to avoid doing two forward passes
               UpperCAmelCase     =	torch.cat([negative_prompt_embeds, prompt_embeds]       )
               UpperCAmelCase     =	torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]       )

               UpperCAmelCase     =	torch.cat([uncond_text_mask, text_mask]       )

           return prompt_embeds, text_encoder_hidden_states, text_mask
       def 					A   (			self		:			Optional[int]     ,       lowercase		:			Union[str, Any]=0       ):



           '''simple docstring'''

           if is_accelerate_available():
               from accelerate import cpu_offload
           else:
               raise ImportError('''Please install accelerate via `pip install accelerate`'''       )

           UpperCAmelCase     =	torch.device(f"cuda:{gpu_id}"       )

           UpperCAmelCase     =	[
               self.unet,
               self.text_encoder,
               self.movq,
           ]
           for cpu_offloaded_model in models:
               if cpu_offloaded_model is not None:
                   cpu_offload(__a     ,       __a       )
       def 					A   (			self		:			Union[str, Any]     ,       lowercase		:			Tuple=0       ):



           '''simple docstring'''

           if is_accelerate_available() and is_accelerate_version('''>='''     ,       '''0.17.0.dev0'''       ):
               from accelerate import cpu_offload_with_hook
           else:
               raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''       )

           UpperCAmelCase     =	torch.device(f"cuda:{gpu_id}"       )

           if self.device.type != "cpu":
               self.to('''cpu'''     ,       silence_dtype_warnings=__a       )
               torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

           UpperCAmelCase     =	None
           for cpu_offloaded_model in [self.text_encoder, self.unet, self.movq]:
               UpperCAmelCase ,  UpperCAmelCase     =	cpu_offload_with_hook(__a     ,       __a     ,       prev_module_hook=__a       )

           if self.safety_checker is not None:
               UpperCAmelCase ,  UpperCAmelCase     =	cpu_offload_with_hook(self.safety_checker     ,       __a     ,       prev_module_hook=__a       )

           # We'll offload the last model manually.
           UpperCAmelCase     =	hook
       @property
       # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           if not hasattr(self.unet     ,       '''_hf_hook'''       ):
               return self.device
           for module in self.unet.modules():
               if (
                   hasattr(__a     ,       '''_hf_hook'''       )
                   and hasattr(module._hf_hook     ,       '''execution_device'''       )
                   and module._hf_hook.execution_device is not None
               ):
                   return torch.device(module._hf_hook.execution_device       )
           return self.device







       @torch.no_grad()
       @replace_example_docstring(__a       )
       def __call__(			self		:			Union[str, Any]     ,       lowercase		:			str     ,       lowercase		:			Union[str, Any]     ,       lowercase		:			Any     ,       lowercase		:			Optional[Any] = None     ,       lowercase		:			Tuple = 512     ,       lowercase		:			List[str] = 512     ,       lowercase		:			int = 100     ,       lowercase		:			Optional[int] = 4.0     ,       lowercase		:			List[str] = 1     ,       lowercase		:			str = None     ,       lowercase		:			Optional[Any] = None     ,       lowercase		:			Tuple = "pil"     ,       lowercase		:			Tuple = True     ,       ):



           '''simple docstring'''

           if isinstance(__a     ,       __a       ):
               UpperCAmelCase     =	1
           elif isinstance(__a     ,       __a       ):
               UpperCAmelCase     =	len(__a       )
           else:
               raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(__a       )}"       )

           UpperCAmelCase     =	self._execution_device

           UpperCAmelCase     =	batch_size * num_images_per_prompt
           UpperCAmelCase     =	guidance_scale > 1.0

           UpperCAmelCase ,  UpperCAmelCase ,  UpperCAmelCase     =	self._encode_prompt(
               __a     ,       __a     ,       __a     ,       __a     ,       __a       )

           if isinstance(__a     ,       __a       ):
               UpperCAmelCase     =	torch.cat(__a     ,       dim=0       )
           if isinstance(__a     ,       __a       ):
               UpperCAmelCase     =	torch.cat(__a     ,       dim=0       )

           if do_classifier_free_guidance:
               UpperCAmelCase     =	image_embeds.repeat_interleave(__a     ,       dim=0       )
               UpperCAmelCase     =	negative_image_embeds.repeat_interleave(__a     ,       dim=0       )

           UpperCAmelCase     =	torch.cat([negative_image_embeds, image_embeds]     ,       dim=0       ).to(
               dtype=prompt_embeds.dtype     ,       device=__a       )

           self.scheduler.set_timesteps(__a     ,       device=__a       )
           UpperCAmelCase     =	self.scheduler.timesteps

           UpperCAmelCase     =	self.unet.config.in_channels

           UpperCAmelCase ,  UpperCAmelCase     =	get_new_h_w(__a     ,       __a     ,       self.movq_scale_factor       )

           # create initial latent
           UpperCAmelCase     =	self.prepare_latents(
               (batch_size, num_channels_latents, height, width)     ,       text_encoder_hidden_states.dtype     ,       __a     ,       __a     ,       __a     ,       self.scheduler     ,       )

           for i, t in enumerate(self.progress_bar(__a       )       ):
               # expand the latents if we are doing classifier free guidance
               UpperCAmelCase     =	torch.cat([latents] * 2       ) if do_classifier_free_guidance else latents

               UpperCAmelCase     =	{'''text_embeds''': prompt_embeds, '''image_embeds''': image_embeds}
               UpperCAmelCase     =	self.unet(
                   sample=__a     ,       timestep=__a     ,       encoder_hidden_states=__a     ,       added_cond_kwargs=__a     ,       return_dict=__a     ,       )[0]

               if do_classifier_free_guidance:
                   UpperCAmelCase ,  UpperCAmelCase     =	noise_pred.split(latents.shape[1]     ,       dim=1       )
                   UpperCAmelCase ,  UpperCAmelCase     =	noise_pred.chunk(2       )
                   UpperCAmelCase ,  UpperCAmelCase     =	variance_pred.chunk(2       )
                   UpperCAmelCase     =	noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
                   UpperCAmelCase     =	torch.cat([noise_pred, variance_pred_text]     ,       dim=1       )

               if not (
                   hasattr(self.scheduler.config     ,       '''variance_type'''       )
                   and self.scheduler.config.variance_type in ["learned", "learned_range"]
               ):
                   UpperCAmelCase ,  UpperCAmelCase     =	noise_pred.split(latents.shape[1]     ,       dim=1       )

               # compute the previous noisy sample x_t -> x_t-1
               UpperCAmelCase     =	self.scheduler.step(
                   __a     ,       __a     ,       __a     ,       generator=__a     ,       ).prev_sample
           # post-processing
           UpperCAmelCase     =	self.movq.decode(__a     ,       force_not_quantize=__a       )['''sample''']

           if output_type not in ["pt", "np", "pil"]:
               raise ValueError(f"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"       )

           if output_type in ["np", "pil"]:
               UpperCAmelCase     =	image * 0.5 + 0.5
               UpperCAmelCase     =	image.clamp(0     ,       1       )
               UpperCAmelCase     =	image.cpu().permute(0     ,       2     ,       3     ,       1       ).float().numpy()

           if output_type == "pil":
               UpperCAmelCase     =	self.numpy_to_pil(__a       )

           if not return_dict:
               return (image,)

           return ImagePipelineOutput(images=__a       )










'''simple docstring'''







import argparse
import math
import traceback

import dateutil.parser as date_parser
import requests





def 		snake_case_							(_a			:							List[str]  ):
    UpperCAmelCase     =	{}

    UpperCAmelCase     =	job['''started_at''']
    UpperCAmelCase     =	job['''completed_at''']

    UpperCAmelCase     =	date_parser.parse(_a  )
    UpperCAmelCase     =	date_parser.parse(_a  )

    UpperCAmelCase     =	round((end_datetime - start_datetime).total_seconds() / 60.0  )

    UpperCAmelCase     =	start
    UpperCAmelCase     =	end
    UpperCAmelCase     =	duration_in_min

    return job_info





def 		snake_case_							(_a			:							str					,     _a			:							List[str]=None  ):
    UpperCAmelCase     =	None
    if token is not None:
        UpperCAmelCase     =	{'''Accept''': '''application/vnd.github+json''', '''Authorization''': F"Bearer {token}"}

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

    try:
        job_time.update({job['''name''']: extract_time_from_single_job(_a  ) for job in result['''jobs''']}  )
        UpperCAmelCase     =	math.ceil((result['''total_count'''] - 1_0_0) / 1_0_0  )

        for i in range(_a  ):
            UpperCAmelCase     =	requests.get(url + F"&page={i + 2}"					,     headers=_a  ).json()
            job_time.update({job['''name''']: extract_time_from_single_job(_a  ) for job in result['''jobs''']}  )

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

    return {}


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.')
   A									=parser.parse_args()

   A									=get_job_time(args.workflow_run_id)
   A									=dict(sorted(job_time.items(), key=lambda item: item[1]["duration"], reverse=True))

   for k, v in job_time.items():
      print(f"""{k}: {v["duration"]}""")




