





import unittest

from transformers import CamembertTokenizer, CamembertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


lowercase_					     =	get_tests_dir("""fixtures/test_sentencepiece.model""")
lowercase_					     =	get_tests_dir("""fixtures/test_sentencepiece_bpe.model""")

lowercase_					     =	"""pt""" if is_torch_available() else """tf"""
@require_sentencepiece
@require_tokenizers
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	str				      = CamembertTokenizer
   _UpperCamelCase					:	Any				      = CamembertTokenizerFast
   _UpperCamelCase					:	List[str]				      = True
   _UpperCamelCase					:	List[str]				      = True


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





     """simple docstring"""







     super().setUp()

     # We have a SentencePiece fixture for testing
     lowercase__			    =						CamembertTokenizer(a )
     tokenizer.save_pretrained(self.tmpdirname )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int] )->     str:





     """simple docstring"""







     lowercase__			    =						'<pad>'
     lowercase__			    =						1

     self.assertEqual(self.get_tokenizer()._convert_token_to_id(a )    ,  a )
     self.assertEqual(self.get_tokenizer()._convert_id_to_token(a )    ,  a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						list(self.get_tokenizer().get_vocab().keys() )

     self.assertEqual(vocab_keys[0]    ,  '<s>NOTUSED' )
     self.assertEqual(vocab_keys[1]    ,  '<pad>' )
     self.assertEqual(vocab_keys[-1]    ,  '<mask>' )
     self.assertEqual(len(a )    ,  1_004 )


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





     """simple docstring"""







     self.assertEqual(self.get_tokenizer().vocab_size    ,  1_005 )


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





     """simple docstring"""







     lowercase__			    =						CamembertTokenizer(a )
     tokenizer.save_pretrained(self.tmpdirname )
     lowercase__			    =						CamembertTokenizerFast.from_pretrained(self.tmpdirname )

     lowercase__			    =						'I was born in 92000, and this is falsé.'

     lowercase__			    =						tokenizer.encode(a )
     lowercase__			    =						rust_tokenizer.encode(a )
     self.assertListEqual(a    ,  a )

     lowercase__			    =						tokenizer.encode(a    ,  add_special_tokens=a )
     lowercase__			    =						rust_tokenizer.encode(a    ,  add_special_tokens=a )
     self.assertListEqual(a    ,  a )

     # <unk> tokens are not the same for `rust` than for `slow`.
     # Because spm gives back raw token instead of `unk` in EncodeAsPieces
     # tokens = tokenizer.tokenize(sequence)
     lowercase__			    =						tokenizer.convert_ids_to_tokens(a )
     lowercase__			    =						rust_tokenizer.tokenize(a )
     self.assertListEqual(a    ,  a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     List[str]:





     """simple docstring"""







     if not self.test_rust_tokenizer:
       return

     lowercase__			    =						self.get_tokenizer()
     lowercase__			    =						self.get_rust_tokenizer()

     lowercase__			    =						'I was born in 92000, and this is falsé.'

     lowercase__			    =						tokenizer.tokenize(a )
     lowercase__			    =						rust_tokenizer.tokenize(a )
     self.assertListEqual(a    ,  a )

     lowercase__			    =						tokenizer.encode(a    ,  add_special_tokens=a )
     lowercase__			    =						rust_tokenizer.encode(a    ,  add_special_tokens=a )
     self.assertListEqual(a    ,  a )

     lowercase__			    =						self.get_rust_tokenizer()
     lowercase__			    =						tokenizer.encode(a )
     lowercase__			    =						rust_tokenizer.encode(a )
     self.assertListEqual(a    ,  a )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any] )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						{'input_ids': [[5, 54, 7_196, 297, 30, 23, 776, 18, 11, 3_215, 3_705, 8_252, 22, 3_164, 1_181, 2_116, 29, 16, 813, 25, 791, 3_314, 20, 3_446, 38, 27_575, 120, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [5, 468, 17, 11, 9_088, 20, 1_517, 8, 22_804, 18_818, 10, 38, 629, 607, 607, 142, 19, 7_196, 867, 56, 10_326, 24, 2_267, 20, 416, 5_072, 15_612, 233, 734, 7, 2_399, 27, 16, 3_015, 1_649, 7, 24, 20, 4_338, 2_399, 27, 13, 3_400, 14, 13, 6_189, 8, 930, 9, 6]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
     # fmt: on

     # camembert is a french model. So we also use french texts.
     lowercase__			    =						[
         'Le transformeur est un modèle d\'apprentissage profond introduit en 2017, '
         'utilisé principalement dans le domaine du traitement automatique des langues (TAL).',
         'À l\'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus '
         'pour gérer des données séquentielles, telles que le langage naturel, pour des tâches '
         'telles que la traduction et la synthèse de texte.',
     ]

     self.tokenizer_integration_test_util(
         expected_encoding=a    ,  model_name='camembert-base'    ,  revision='3a0641d9a1aeb7e848a74299e7e4c4bca216b4cf'    ,  sequences=a    ,  )









import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	List[Any]				      = StableDiffusionSAGPipeline
   _UpperCamelCase					:	str				      = TEXT_TO_IMAGE_PARAMS
   _UpperCamelCase					:	Dict				      = TEXT_TO_IMAGE_BATCH_PARAMS
   _UpperCamelCase					:	str				      = TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase					:	Optional[int]				      = TEXT_TO_IMAGE_IMAGE_PARAMS
   _UpperCamelCase					:	Union[str, Any]				      = False


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     Dict:





     """simple docstring"""







     torch.manual_seed(0 )
     lowercase__			    =						UNetaDConditionModel(
         block_out_channels=(32, 64)    ,  layers_per_block=2    ,  sample_size=32    ,  in_channels=4    ,  out_channels=4    ,  down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')    ,  up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')    ,  cross_attention_dim=32    ,  )
     lowercase__			    =						DDIMScheduler(
         beta_start=0.00085    ,  beta_end=0.012    ,  beta_schedule='scaled_linear'    ,  clip_sample=a    ,  set_alpha_to_one=a    ,  )
     torch.manual_seed(0 )
     lowercase__			    =						AutoencoderKL(
         block_out_channels=[32, 64]    ,  in_channels=3    ,  out_channels=3    ,  down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']    ,  up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']    ,  latent_channels=4    ,  )
     torch.manual_seed(0 )
     lowercase__			    =						CLIPTextConfig(
         bos_token_id=0    ,  eos_token_id=2    ,  hidden_size=32    ,  intermediate_size=37    ,  layer_norm_eps=1E-0_5    ,  num_attention_heads=4    ,  num_hidden_layers=5    ,  pad_token_id=1    ,  vocab_size=1_000    ,  )
     lowercase__			    =						CLIPTextModel(a )
     lowercase__			    =						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

     lowercase__			    =						{
         'unet': unet,
         'scheduler': scheduler,
         'vae': vae,
         'text_encoder': text_encoder,
         'tokenizer': tokenizer,
         'safety_checker': None,
         'feature_extractor': None,
     }
     return components


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple    ,  a    :       Optional[int]    ,  a    :       Any=0 )->     Union[str, Any]:





     """simple docstring"""







     if str(a ).startswith('mps' ):
       lowercase__			    =						torch.manual_seed(a )
     else:
       lowercase__			    =						torch.Generator(device=a ).manual_seed(a )
     lowercase__			    =						{
         'prompt': '.',
         'generator': generator,
         'num_inference_steps': 2,
         'guidance_scale': 1.0,
         'sag_scale': 1.0,
         'output_type': 'numpy',
     }
     return inputs


   def  SCREAMING_SNAKE_CASE_							(					self    :       Any )->     Any:





     """simple docstring"""







     super().test_inference_batch_single_identical(expected_max_diff=3E-3 )






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


   def  SCREAMING_SNAKE_CASE_							(					self    :       str )->     int:





     """simple docstring"""







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


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np' )

     lowercase__			    =						output.images

     lowercase__			    =						image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949] )

     assert np.abs(image_slice.flatten() - expected_slice ).max() < 5E-2


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np' )

     lowercase__			    =						output.images

     lowercase__			    =						image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     lowercase__			    =						np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371] )

     assert np.abs(image_slice.flatten() - expected_slice ).max() < 5E-2


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





     """simple docstring"""







     lowercase__			    =						StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' )
     lowercase__			    =						sag_pipe.to(a )
     sag_pipe.set_progress_bar_config(disable=a )

     lowercase__			    =						'.'
     lowercase__			    =						torch.manual_seed(0 )
     lowercase__			    =						sag_pipe(
         [prompt]    ,  width=768    ,  height=512    ,  generator=a    ,  guidance_scale=7.5    ,  sag_scale=1.0    ,  num_inference_steps=20    ,  output_type='np'    ,  )

     lowercase__			    =						output.images

     assert image.shape == (1, 512, 768, 3)


