



"""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


__snake_case							:     Any   =					False



class     A__     (						unittest.TestCase							):




	'''simple docstring'''





	def 							_SCREAMING_SNAKE_CASE     (  self:	Optional[Any])       -> Union[str, Any]:

				"""simple docstring"""

				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict)       -> List[Any]:

				"""simple docstring"""

				return 12

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	Tuple)       -> int:

				"""simple docstring"""

				return 12

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict)       -> Any:

				"""simple docstring"""

				return 32

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	Tuple)       -> int:

				"""simple docstring"""

				torch.manual_seed(0)
				__lowerCAmelCase   :						Tuple				= 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 							_SCREAMING_SNAKE_CASE     (  self:	Optional[Any])       -> Optional[int]:

				"""simple docstring"""

				__lowerCAmelCase   :						List[str]				= CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
				return tokenizer

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	List[Any])       -> str:

				"""simple docstring"""

				torch.manual_seed(0)
				__lowerCAmelCase   :						int				= CLIPTextConfig(
				    bos_token_id=0 ,    eos_token_id=2 ,    hidden_size=self.text_embedder_hidden_size ,    intermediate_size=37 ,    layer_norm_eps=1e-05 ,    num_attention_heads=4 ,    num_hidden_layers=5 ,    pad_token_id=1 ,    vocab_size=1000 ,    )
				return CLIPTextModel(_SCREAMING_SNAKE_CASE)

	@property
	def 							_SCREAMING_SNAKE_CASE     (  self:	str)       -> str:

				"""simple docstring"""

				torch.manual_seed(0)

				__lowerCAmelCase   :						Optional[int]				= 12
				__lowerCAmelCase   :						Tuple				= 12

				__lowerCAmelCase   :						Optional[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",
				}

				__lowerCAmelCase   :						str				= TransformeraDModel(**_SCREAMING_SNAKE_CASE)
				return model

	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict)       -> Optional[Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						List[str]				= "cpu"

				__lowerCAmelCase   :						str				= self.dummy_vqvae
				__lowerCAmelCase   :						List[Any]				= self.dummy_text_encoder
				__lowerCAmelCase   :						str				= self.dummy_tokenizer
				__lowerCAmelCase   :						str				= self.dummy_transformer
				__lowerCAmelCase   :						List[Any]				= VQDiffusionScheduler(self.num_embed)
				__lowerCAmelCase   :						Any				= LearnedClassifierFreeSamplingEmbeddings(learnable=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Union[str, Any]				= VQDiffusionPipeline(
				    vqvae=_SCREAMING_SNAKE_CASE ,    text_encoder=_SCREAMING_SNAKE_CASE ,    tokenizer=_SCREAMING_SNAKE_CASE ,    transformer=_SCREAMING_SNAKE_CASE ,    scheduler=_SCREAMING_SNAKE_CASE ,    learned_classifier_free_sampling_embeddings=_SCREAMING_SNAKE_CASE ,    )
				__lowerCAmelCase   :						Union[str, Any]				= pipe.to(_SCREAMING_SNAKE_CASE)
				pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase   :						Tuple				= "teddy bear playing in the pool"

				__lowerCAmelCase   :						Optional[int]				= torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
				__lowerCAmelCase   :						Any				= pipe([prompt] ,    generator=_SCREAMING_SNAKE_CASE ,    num_inference_steps=2 ,    output_type="np")
				__lowerCAmelCase   :						List[Any]				= output.images

				__lowerCAmelCase   :						int				= torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
				__lowerCAmelCase   :						Tuple				= pipe(
				    [prompt] ,    generator=_SCREAMING_SNAKE_CASE ,    output_type="np" ,    return_dict=_SCREAMING_SNAKE_CASE ,    num_inference_steps=2)[0]

				__lowerCAmelCase   :						Union[str, Any]				= image[0, -3:, -3:, -1]
				__lowerCAmelCase   :						Tuple				= image_from_tuple[0, -3:, -3:, -1]

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

				__lowerCAmelCase   :						Optional[Any]				= np.array([0.6551, 0.6168, 0.5008, 0.5676, 0.5659, 0.4295, 0.6073, 0.5599, 0.4992])

				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 							_SCREAMING_SNAKE_CASE     (  self:	Dict)       -> Union[str, Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Optional[int]				= "cpu"

				__lowerCAmelCase   :						Optional[int]				= self.dummy_vqvae
				__lowerCAmelCase   :						Optional[int]				= self.dummy_text_encoder
				__lowerCAmelCase   :						int				= self.dummy_tokenizer
				__lowerCAmelCase   :						Any				= self.dummy_transformer
				__lowerCAmelCase   :						Optional[int]				= VQDiffusionScheduler(self.num_embed)
				__lowerCAmelCase   :						Union[str, Any]				= LearnedClassifierFreeSamplingEmbeddings(
				    learnable=_SCREAMING_SNAKE_CASE ,    hidden_size=self.text_embedder_hidden_size ,    length=tokenizer.model_max_length)

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

				__lowerCAmelCase   :						List[Any]				= "teddy bear playing in the pool"

				__lowerCAmelCase   :						int				= torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
				__lowerCAmelCase   :						int				= pipe([prompt] ,    generator=_SCREAMING_SNAKE_CASE ,    num_inference_steps=2 ,    output_type="np")
				__lowerCAmelCase   :						Optional[int]				= output.images

				__lowerCAmelCase   :						int				= torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
				__lowerCAmelCase   :						Union[str, Any]				= pipe(
				    [prompt] ,    generator=_SCREAMING_SNAKE_CASE ,    output_type="np" ,    return_dict=_SCREAMING_SNAKE_CASE ,    num_inference_steps=2)[0]

				__lowerCAmelCase   :						int				= image[0, -3:, -3:, -1]
				__lowerCAmelCase   :						Any				= image_from_tuple[0, -3:, -3:, -1]

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

				__lowerCAmelCase   :						Union[str, Any]				= np.array([0.6693, 0.6075, 0.4959, 0.5701, 0.5583, 0.4333, 0.6171, 0.5684, 0.4988])

				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     A__     (						unittest.TestCase							):




	'''simple docstring'''





	def 							_SCREAMING_SNAKE_CASE     (  self:	List[Any])       -> str:

				"""simple docstring"""

				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()







	def 							_SCREAMING_SNAKE_CASE     (  self:	Optional[Any])       -> Optional[int]:

				"""simple docstring"""

				__lowerCAmelCase   :						int				= load_numpy(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy")

				__lowerCAmelCase   :						Any				= VQDiffusionPipeline.from_pretrained("microsoft/vq-diffusion-ithq")
				__lowerCAmelCase   :						Tuple				= pipeline.to(_SCREAMING_SNAKE_CASE)
				pipeline.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

				# requires GPU generator for gumbel softmax
				# don't use GPU generator in tests though
				__lowerCAmelCase   :						List[str]				= torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
				__lowerCAmelCase   :						List[Any]				= pipeline(
				    "teddy bear playing in the pool" ,    num_images_per_prompt=1 ,    generator=_SCREAMING_SNAKE_CASE ,    output_type="np" ,    )

				__lowerCAmelCase   :						List[Any]				= output.images[0]

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




"""simple docstring"""






def     _lowercase       (						__snake_case      ,__snake_case			)		->     list:
			__lowerCAmelCase   :						List[str]				= len(__snake_case			)
			__lowerCAmelCase   :						Dict				= []
			for i in range(len(__snake_case			) - pat_len + 1			):
						__lowerCAmelCase   :						List[Any]				= True
						for j in range(__snake_case			):
									if s[i + j] != pattern[j]:
												__lowerCAmelCase   :						Union[str, Any]				= False
												break
						if match_found:
									position.append(__snake_case			)
			return position


if __name__ == "__main__":
	assert naive_pattern_search('ABCDEFG', 'DE') == [3]
	print(naive_pattern_search('ABAAABCDBBABCDDEBCABC', 'ABC'))