"""simple docstring"""






import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


__A			   = False


class     UpperCAmelCase						(unittest.TestCase  ):



    """simple docstring"""

    def _snake_case			(   self							):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()






    @property
    def _snake_case			(   self							):
       return 12






    @property
    def _snake_case			(   self							):
       return 12






    @property
    def _snake_case			(   self							):
       return 32






    @property
    def _snake_case			(   self							):
       torch.manual_seed(0							)
       lowercase__:   Any					=      VQModel(
           block_out_channels=[32, 64]    ,			in_channels=3    ,			out_channels=3    ,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']    ,			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']    ,			latent_channels=3    ,			num_vq_embeddings=self.num_embed    ,			vq_embed_dim=3    ,			)
       return model






    @property
    def _snake_case			(   self							):
       lowercase__:   Any					=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)
       return tokenizer






    @property
    def _snake_case			(   self							):
       torch.manual_seed(0							)
       lowercase__:   str					=      CLIPTextConfig(
           bos_token_id=0    ,			eos_token_id=2    ,			hidden_size=self.text_embedder_hidden_size    ,			intermediate_size=37    ,			layer_norm_eps=1e-0_5    ,			num_attention_heads=4    ,			num_hidden_layers=5    ,			pad_token_id=1    ,			vocab_size=1000    ,			)
       return CLIPTextModel(_UpperCAmelCase							)






    @property
    def _snake_case			(   self							):
       torch.manual_seed(0							)

       lowercase__:   List[str]					=      12
       lowercase__:   Dict					=      12

       lowercase__:   int					=      {
           '''attention_bias''': True,
           '''cross_attention_dim''': 32,
           '''attention_head_dim''': height * width,
           '''num_attention_heads''': 1,
           '''num_vector_embeds''': self.num_embed,
           '''num_embeds_ada_norm''': self.num_embeds_ada_norm,
           '''norm_num_groups''': 32,
           '''sample_size''': width,
           '''activation_fn''': '''geglu-approximate''',
       }

       lowercase__:   List[str]					=      TransformeraDModel(**_UpperCAmelCase							)
       return model






    def _snake_case			(   self							):
       lowercase__:   Any					=      '''cpu'''

       lowercase__:   Optional[Any]					=      self.dummy_vqvae
       lowercase__:   Tuple					=      self.dummy_text_encoder
       lowercase__:   List[Any]					=      self.dummy_tokenizer
       lowercase__:   int					=      self.dummy_transformer
       lowercase__:   Optional[Any]					=      VQDiffusionScheduler(self.num_embed							)
       lowercase__:   Dict					=      LearnedClassifierFreeSamplingEmbeddings(learnable=_UpperCAmelCase							)

       lowercase__:   List[str]					=      VQDiffusionPipeline(
           vqvae=_UpperCAmelCase    ,			text_encoder=_UpperCAmelCase    ,			tokenizer=_UpperCAmelCase    ,			transformer=_UpperCAmelCase    ,			scheduler=_UpperCAmelCase    ,			learned_classifier_free_sampling_embeddings=_UpperCAmelCase    ,			)
       lowercase__:   Any					=      pipe.to(_UpperCAmelCase							)
       pipe.set_progress_bar_config(disable=_UpperCAmelCase							)

       lowercase__:   str					=      '''teddy bear playing in the pool'''

       lowercase__:   Any					=      torch.Generator(device=_UpperCAmelCase							).manual_seed(0							)
       lowercase__:   Tuple					=      pipe([prompt]    ,			generator=_UpperCAmelCase    ,			num_inference_steps=2    ,			output_type='''np'''							)
       lowercase__:   Optional[Any]					=      output.images

       lowercase__:   Tuple					=      torch.Generator(device=_UpperCAmelCase							).manual_seed(0							)
       lowercase__:   List[str]					=      pipe(
           [prompt]    ,			generator=_UpperCAmelCase    ,			output_type='''np'''    ,			return_dict=_UpperCAmelCase    ,			num_inference_steps=2							)[0]

       lowercase__:   int					=      image[0, -3:, -3:, -1]
       lowercase__:   List[str]					=      image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 24, 24, 3)

       lowercase__:   Union[str, Any]					=      np.array([0.6_551, 0.6_168, 0.5_008, 0.5_676, 0.5_659, 0.4_295, 0.6_073, 0.5_599, 0.4_992]							)

       assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 1e-2






    def _snake_case			(   self							):
       lowercase__:   Any					=      '''cpu'''

       lowercase__:   List[Any]					=      self.dummy_vqvae
       lowercase__:   Optional[Any]					=      self.dummy_text_encoder
       lowercase__:   Union[str, Any]					=      self.dummy_tokenizer
       lowercase__:   Tuple					=      self.dummy_transformer
       lowercase__:   Tuple					=      VQDiffusionScheduler(self.num_embed							)
       lowercase__:   str					=      LearnedClassifierFreeSamplingEmbeddings(
           learnable=_UpperCAmelCase    ,			hidden_size=self.text_embedder_hidden_size    ,			length=tokenizer.model_max_length							)

       lowercase__:   str					=      VQDiffusionPipeline(
           vqvae=_UpperCAmelCase    ,			text_encoder=_UpperCAmelCase    ,			tokenizer=_UpperCAmelCase    ,			transformer=_UpperCAmelCase    ,			scheduler=_UpperCAmelCase    ,			learned_classifier_free_sampling_embeddings=_UpperCAmelCase    ,			)
       lowercase__:   int					=      pipe.to(_UpperCAmelCase							)
       pipe.set_progress_bar_config(disable=_UpperCAmelCase							)

       lowercase__:   Tuple					=      '''teddy bear playing in the pool'''

       lowercase__:   Dict					=      torch.Generator(device=_UpperCAmelCase							).manual_seed(0							)
       lowercase__:   List[Any]					=      pipe([prompt]    ,			generator=_UpperCAmelCase    ,			num_inference_steps=2    ,			output_type='''np'''							)
       lowercase__:   Optional[int]					=      output.images

       lowercase__:   str					=      torch.Generator(device=_UpperCAmelCase							).manual_seed(0							)
       lowercase__:   Optional[Any]					=      pipe(
           [prompt]    ,			generator=_UpperCAmelCase    ,			output_type='''np'''    ,			return_dict=_UpperCAmelCase    ,			num_inference_steps=2							)[0]

       lowercase__:   List[Any]					=      image[0, -3:, -3:, -1]
       lowercase__:   Optional[int]					=      image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 24, 24, 3)

       lowercase__:   int					=      np.array([0.6_693, 0.6_075, 0.4_959, 0.5_701, 0.5_583, 0.4_333, 0.6_171, 0.5_684, 0.4_988]							)

       assert np.abs(image_slice.flatten() - expected_slice							).max() < 2.0
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 1e-2



@slow
@require_torch_gpu
class     UpperCAmelCase						(unittest.TestCase  ):



    """simple docstring"""

    def _snake_case			(   self							):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()






    def _snake_case			(   self							):
       lowercase__:   int					=      load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy'''							)

       lowercase__:   Union[str, Any]					=      VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq'''							)
       lowercase__:   Union[str, Any]					=      pipeline.to(_UpperCAmelCase							)
       pipeline.set_progress_bar_config(disable=_UpperCAmelCase							)

       # requires GPU generator for gumbel softmax
       # don't use GPU generator in tests though
       lowercase__:   Any					=      torch.Generator(device=_UpperCAmelCase							).manual_seed(0							)
       lowercase__:   Dict					=      pipeline(
           '''teddy bear playing in the pool'''    ,			num_images_per_prompt=1    ,			generator=_UpperCAmelCase    ,			output_type='''np'''    ,			)

       lowercase__:   List[str]					=      output.images[0]

       assert image.shape == (256, 256, 3)
       assert np.abs(expected_image - image							).max() < 2.0

"""simple docstring"""






from collections.abc import Sequence



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase = False )  ->  float:
   if not arr:
      return 0

   lowercase__:   Any					=      0 if allow_empty_subarrays else float('''-inf''' )
   lowercase__:   Union[str, Any]					=      0.0
   for num in arr:
      lowercase__:   List[str]					=      max(0 if allow_empty_subarrays else num       ,    curr_sum + num )
      lowercase__:   int					=      max(__UpperCAmelCase       ,    __UpperCAmelCase )

   return max_sum


if __name__ == "__main__":
       from doctest import testmod

       testmod()

       __A			   = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
       print(f'''{max_subarray_sum(nums) = }''')
