
import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class 				lowercase		(					unittest.TestCase		):




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




							@property
							def  A__      (				self):
												lowercase							=						1
												lowercase							=						3
												lowercase							=						(3_2, 3_2)

												lowercase							=						floats_tensor((batch_size, num_channels) + sizes   ,rng=random.Random(0)).to(A__)
												return image




							@property
							def  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						UNetaDConditionModel(
												    block_out_channels=(3_2, 6_4)   ,layers_per_block=2   ,sample_size=3_2   ,in_channels=4   ,out_channels=4   ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')   ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')   ,cross_attention_dim=3_2   ,)
												return model




							@property
							def  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						AutoencoderKL(
												    block_out_channels=[3_2, 6_4]   ,in_channels=3   ,out_channels=3   ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']   ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']   ,latent_channels=4   ,)
												return model




							@property
							def  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						RobertaSeriesConfig(
												    hidden_size=3_2   ,project_dim=3_2   ,intermediate_size=3_7   ,layer_norm_eps=1E-05   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=5_0_0_6   ,)
												return RobertaSeriesModelWithTransformation(A__)




							@property
							def  A__      (				self):
												def extract(*A__   ,**A__):







																	class 				lowercase		:




																								def __init__(				self):
																													lowercase							=						torch.ones([0])





																								def  A__      (				self   ,A__):
																													self.pixel_values.to(A__)
																													return self


																	return Out()

												return extract




							def  A__      (				self):
												lowercase							=						'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												lowercase							=						self.dummy_cond_unet
												lowercase							=						PNDMScheduler(skip_prk_steps=A__)
												lowercase							=						self.dummy_vae
												lowercase							=						self.dummy_text_encoder
												lowercase							=						XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''')
												lowercase							=						7_7

												lowercase							=						self.dummy_image.to(A__)
												lowercase							=						init_image / 2 + 0.5

												# make sure here that pndm scheduler skips prk
												lowercase							=						AltDiffusionImgaImgPipeline(
												    unet=A__   ,scheduler=A__   ,vae=A__   ,text_encoder=A__   ,tokenizer=A__   ,safety_checker=A__   ,feature_extractor=self.dummy_extractor   ,)
												lowercase							=						VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor   ,do_normalize=A__)
												lowercase							=						alt_pipe.to(A__)
												alt_pipe.set_progress_bar_config(disable=A__)

												lowercase							=						'''A painting of a squirrel eating a burger'''
												lowercase							=						torch.Generator(device=A__).manual_seed(0)
												lowercase							=						alt_pipe(
												    [prompt]   ,generator=A__   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   ,image=A__   ,)

												lowercase							=						output.images

												lowercase							=						torch.Generator(device=A__).manual_seed(0)
												lowercase							=						alt_pipe(
												    [prompt]   ,generator=A__   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   ,image=A__   ,return_dict=A__   ,)[0]

												lowercase							=						image[0, -3:, -3:, -1]
												lowercase							=						image_from_tuple[0, -3:, -3:, -1]

												assert image.shape == (1, 3_2, 3_2, 3)
												lowercase							=						np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499])

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




							@unittest.skipIf(torch_device != '''cuda'''   ,'''This test requires a GPU''')
							def  A__      (				self):
												lowercase							=						self.dummy_cond_unet
												lowercase							=						PNDMScheduler(skip_prk_steps=A__)
												lowercase							=						self.dummy_vae
												lowercase							=						self.dummy_text_encoder
												lowercase							=						XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''')
												lowercase							=						7_7

												lowercase							=						self.dummy_image.to(A__)

												# put models in fp16
												lowercase							=						unet.half()
												lowercase							=						vae.half()
												lowercase							=						bert.half()

												# make sure here that pndm scheduler skips prk
												lowercase							=						AltDiffusionImgaImgPipeline(
												    unet=A__   ,scheduler=A__   ,vae=A__   ,text_encoder=A__   ,tokenizer=A__   ,safety_checker=A__   ,feature_extractor=self.dummy_extractor   ,)
												lowercase							=						VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor   ,do_normalize=A__)
												lowercase							=						alt_pipe.to(A__)
												alt_pipe.set_progress_bar_config(disable=A__)

												lowercase							=						'''A painting of a squirrel eating a burger'''
												lowercase							=						torch.manual_seed(0)
												lowercase							=						alt_pipe(
												    [prompt]   ,generator=A__   ,num_inference_steps=2   ,output_type='''np'''   ,image=A__   ,).images

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





							@unittest.skipIf(torch_device != '''cuda'''   ,'''This test requires a GPU''')
							def  A__      (				self):
												lowercase							=						load_image(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
												    '''/img2img/sketch-mountains-input.jpg''')
												# resize to resolution that is divisible by 8 but not 16 or 32
												lowercase							=						init_image.resize((7_6_0, 5_0_4))

												lowercase							=						'''BAAI/AltDiffusion'''
												lowercase							=						AltDiffusionImgaImgPipeline.from_pretrained(
												    A__   ,safety_checker=A__   ,)
												pipe.to(A__)
												pipe.set_progress_bar_config(disable=A__)
												pipe.enable_attention_slicing()

												lowercase							=						'''A fantasy landscape, trending on artstation'''

												lowercase							=						torch.manual_seed(0)
												lowercase							=						pipe(
												    prompt=A__   ,image=A__   ,strength=0.75   ,guidance_scale=7.5   ,generator=A__   ,output_type='''np'''   ,)
												lowercase							=						output.images[0]

												lowercase							=						image[2_5_5:2_5_8, 3_8_3:3_8_6, -1]

												assert image.shape == (5_0_4, 7_6_0, 3)
												lowercase							=						np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000])

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







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




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





							def  A__      (				self):
												lowercase							=						load_image(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
												    '''/img2img/sketch-mountains-input.jpg''')
												lowercase							=						init_image.resize((7_6_8, 5_1_2))
												lowercase							=						load_numpy(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy''')

												lowercase							=						'''BAAI/AltDiffusion'''
												lowercase							=						AltDiffusionImgaImgPipeline.from_pretrained(
												    A__   ,safety_checker=A__   ,)
												pipe.to(A__)
												pipe.set_progress_bar_config(disable=A__)
												pipe.enable_attention_slicing()

												lowercase							=						'''A fantasy landscape, trending on artstation'''

												lowercase							=						torch.manual_seed(0)
												lowercase							=						pipe(
												    prompt=A__   ,image=A__   ,strength=0.75   ,guidance_scale=7.5   ,generator=A__   ,output_type='''np'''   ,)
												lowercase							=						output.images[0]

												assert image.shape == (5_1_2, 7_6_8, 3)
												# img2img is flaky across GPUs even in fp32, so using MAE here
												assert np.abs(expected_image - image).max() < 1E-2






import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english







@require_tokenizers
class 				lowercase		(					SCREAMING_SNAKE_CASE__       ,  unittest.TestCase		):
							lowercase_       :       Union[str, Any]       					=RoCBertTokenizer
							lowercase_       :       str       					=None
							lowercase_       :       Optional[Any]       					=False
							lowercase_       :       Any       					=True
							lowercase_       :       int       					=filter_non_english




							def  A__      (				self):
												super().setUp()

												lowercase							=						['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''你''', '''好''', '''是''', '''谁''', '''a''', '''b''', '''c''', '''d''']
												lowercase							=						{}
												lowercase							=						{}
												for i, value in enumerate(A__):
																	lowercase							=						i
																	lowercase							=						i
												lowercase							=						os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES['''vocab_file'''])
												lowercase							=						os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES['''word_shape_file'''])
												lowercase							=						os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES['''word_pronunciation_file'''])
												with open(self.vocab_file   ,'''w'''   ,encoding='''utf-8''') as vocab_writer:
																	vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]))
												with open(self.word_shape_file   ,'''w'''   ,encoding='''utf-8''') as word_shape_writer:
																	json.dump(A__   ,A__   ,ensure_ascii=A__)
												with open(self.word_pronunciation_file   ,'''w'''   ,encoding='''utf-8''') as word_pronunciation_writer:
																	json.dump(A__   ,A__   ,ensure_ascii=A__)




							def  A__      (				self):
												lowercase							=						self.tokenizer_class(self.vocab_file   ,self.word_shape_file   ,self.word_pronunciation_file)

												lowercase							=						tokenizer.tokenize('''你好[SEP]你是谁''')
												self.assertListEqual(A__   ,['''你''', '''好''', '''[SEP]''', '''你''', '''是''', '''谁'''])
												self.assertListEqual(tokenizer.convert_tokens_to_ids(A__)   ,[5, 6, 2, 5, 7, 8])
												self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(A__)   ,[5, 6, 2, 5, 7, 8])
												self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(A__)   ,[5, 6, 2, 5, 7, 8])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer()

												self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz''')   ,['''ah''', '''\u535A''', '''\u63A8''', '''zz'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__)

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''')   ,['''hello''', '''!''', '''how''', '''are''', '''you''', '''?'''])
												self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')   ,['''hello'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__   ,strip_accents=A__)

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')   ,['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?'''])
												self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')   ,['''h\u00E9llo'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__   ,strip_accents=A__)

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')   ,['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''])
												self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')   ,['''hello'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__)

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')   ,['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''])
												self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')   ,['''hello'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__)

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''')   ,['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__   ,strip_accents=A__)

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')   ,['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__   ,strip_accents=A__)

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')   ,['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''])




							def  A__      (				self):
												lowercase							=						RoCBertBasicTokenizer(do_lower_case=A__   ,never_split=['''[UNK]'''])

												self.assertListEqual(
												    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]''')   ,['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]'''])




							def  A__      (				self):
												lowercase							=						['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

												lowercase							=						{}
												for i, token in enumerate(A__):
																	lowercase							=						i
												lowercase							=						RoCBertWordpieceTokenizer(vocab=A__   ,unk_token='''[UNK]''')

												self.assertListEqual(tokenizer.tokenize('''''')   ,[])

												self.assertListEqual(tokenizer.tokenize('''unwanted running''')   ,['''un''', '''##want''', '''##ed''', '''runn''', '''##ing'''])

												self.assertListEqual(tokenizer.tokenize('''unwantedX running''')   ,['''[UNK]''', '''runn''', '''##ing'''])




							def  A__      (				self):
												self.assertTrue(_is_whitespace(''' '''))
												self.assertTrue(_is_whitespace('''\t'''))
												self.assertTrue(_is_whitespace('''\r'''))
												self.assertTrue(_is_whitespace('''\n'''))
												self.assertTrue(_is_whitespace('''\u00A0'''))

												self.assertFalse(_is_whitespace('''A'''))
												self.assertFalse(_is_whitespace('''-'''))




							def  A__      (				self):
												self.assertTrue(_is_control('''\u0005'''))

												self.assertFalse(_is_control('''A'''))
												self.assertFalse(_is_control(''' '''))
												self.assertFalse(_is_control('''\t'''))
												self.assertFalse(_is_control('''\r'''))




							def  A__      (				self):
												self.assertTrue(_is_punctuation('''-'''))
												self.assertTrue(_is_punctuation('''$'''))
												self.assertTrue(_is_punctuation('''`'''))
												self.assertTrue(_is_punctuation('''.'''))

												self.assertFalse(_is_punctuation('''A'''))
												self.assertFalse(_is_punctuation(''' '''))




							def  A__      (				self):
												lowercase							=						self.get_tokenizer()

												# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
												self.assertListEqual([tokenizer.tokenize(A__) for t in ['''Test''', '''\xad''', '''test''']]   ,[['''[UNK]'''], [], ['''[UNK]''']])

												if self.test_rust_tokenizer:
																	lowercase							=						self.get_rust_tokenizer()
																	self.assertListEqual(
																	    [rust_tokenizer.tokenize(A__) for t in ['''Test''', '''\xad''', '''test''']]   ,[['''[UNK]'''], [], ['''[UNK]''']])




							def  A__      (				self):
												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'):
																						lowercase							=						self.rust_tokenizer_class.from_pretrained(A__   ,**A__)

																						lowercase							=						f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
																						lowercase							=						tokenizer_r.encode_plus(
																						    A__   ,return_attention_mask=A__   ,return_token_type_ids=A__   ,return_offsets_mapping=A__   ,add_special_tokens=A__   ,)

																						lowercase							=						tokenizer_r.do_lower_case if hasattr(A__   ,'''do_lower_case''') else False
																						lowercase							=						(
																						    [
																						        ((0, 0), tokenizer_r.cls_token),
																						        ((0, 1), '''A'''),
																						        ((1, 2), ''','''),
																						        ((3, 5), '''na'''),
																						        ((5, 6), '''##ï'''),
																						        ((6, 8), '''##ve'''),
																						        ((9, 1_5), tokenizer_r.mask_token),
																						        ((1_6, 2_1), '''Allen'''),
																						        ((2_1, 2_3), '''##NL'''),
																						        ((2_3, 2_4), '''##P'''),
																						        ((2_5, 3_3), '''sentence'''),
																						        ((3_3, 3_4), '''.'''),
																						        ((0, 0), tokenizer_r.sep_token),
																						    ]
																						    if not do_lower_case
																						    else [
																						        ((0, 0), tokenizer_r.cls_token),
																						        ((0, 1), '''a'''),
																						        ((1, 2), ''','''),
																						        ((3, 8), '''naive'''),
																						        ((9, 1_5), tokenizer_r.mask_token),
																						        ((1_6, 2_1), '''allen'''),
																						        ((2_1, 2_3), '''##nl'''),
																						        ((2_3, 2_4), '''##p'''),
																						        ((2_5, 3_3), '''sentence'''),
																						        ((3_3, 3_4), '''.'''),
																						        ((0, 0), tokenizer_r.sep_token),
																						    ]
																						)

																						self.assertEqual(
																						    [e[1] for e in expected_results]   ,tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']))
																						self.assertEqual([e[0] for e in expected_results]   ,tokens['''offset_mapping'''])




							def  A__      (				self):
												lowercase							=						['''的''', '''人''', '''有''']
												lowercase							=						''''''.join(A__)
												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'):
																						lowercase							=						True
																						lowercase							=						self.tokenizer_class.from_pretrained(A__   ,**A__)
																						lowercase							=						self.rust_tokenizer_class.from_pretrained(A__   ,**A__)

																						lowercase							=						tokenizer_p.encode(A__   ,add_special_tokens=A__)
																						lowercase							=						tokenizer_r.encode(A__   ,add_special_tokens=A__)

																						lowercase							=						tokenizer_r.convert_ids_to_tokens(A__)
																						lowercase							=						tokenizer_p.convert_ids_to_tokens(A__)

																						# it is expected that each Chinese character is not preceded by "##"
																						self.assertListEqual(A__   ,A__)
																						self.assertListEqual(A__   ,A__)

																						lowercase							=						False
																						lowercase							=						self.rust_tokenizer_class.from_pretrained(A__   ,**A__)
																						lowercase							=						self.tokenizer_class.from_pretrained(A__   ,**A__)

																						lowercase							=						tokenizer_r.encode(A__   ,add_special_tokens=A__)
																						lowercase							=						tokenizer_p.encode(A__   ,add_special_tokens=A__)

																						lowercase							=						tokenizer_r.convert_ids_to_tokens(A__)
																						lowercase							=						tokenizer_p.convert_ids_to_tokens(A__)

																						# it is expected that only the first Chinese character is not preceded by "##".
																						lowercase							=						[
																						    f'##{token}' if idx != 0 else token for idx, token in enumerate(A__)
																						]
																						self.assertListEqual(A__   ,A__)
																						self.assertListEqual(A__   ,A__)




							@slow
							def  A__      (				self):
												lowercase							=						self.tokenizer_class(self.vocab_file   ,self.word_shape_file   ,self.word_pronunciation_file)

												lowercase							=						tokenizer.encode('''你好'''   ,add_special_tokens=A__)
												lowercase							=						tokenizer.encode('''你是谁'''   ,add_special_tokens=A__)

												lowercase							=						tokenizer.build_inputs_with_special_tokens(A__)
												lowercase							=						tokenizer.build_inputs_with_special_tokens(A__   ,A__)

												assert encoded_sentence == [1] + text + [2]
												assert encoded_pair == [1] + text + [2] + text_a + [2]





							def  A__      (				self):
												lowercase							=						self.get_tokenizers(do_lower_case=A__)
												for tokenizer in tokenizers:
																	with self.subTest(f'{tokenizer.__class__.__name__}'):
																						lowercase							=						'''你好，你是谁'''
																						lowercase							=						tokenizer.tokenize(A__)
																						lowercase							=						tokenizer.convert_tokens_to_ids(A__)
																						lowercase							=						tokenizer.convert_tokens_to_shape_ids(A__)
																						lowercase							=						tokenizer.convert_tokens_to_pronunciation_ids(A__)
																						lowercase							=						tokenizer.prepare_for_model(
																						    A__   ,A__   ,A__   ,add_special_tokens=A__)

																						lowercase							=						tokenizer.encode_plus(A__   ,add_special_tokens=A__)

																						self.assertEqual(A__   ,A__)




