



'''simple docstring'''



import json
from typing import TYPE_CHECKING, List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_blenderbot import BlenderbotTokenizer


if TYPE_CHECKING:
		from transformers.pipelines.conversational import Conversation

lowerCamelCase	 =       logging.get_logger(__name__)


lowerCamelCase	 =       {
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
    "tokenizer_config_file": "tokenizer_config.json",
}

lowerCamelCase	 =       {
    "vocab_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"},
    "merges_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"},
    "tokenizer_config_file": {
        "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json"
    },
}

lowerCamelCase	 =       {"facebook/blenderbot-3B": 128}





class __SCREAMING_SNAKE_CASE		(     A		):





				'''simple docstring'''





				lowerCAmelCase__					    =    VOCAB_FILES_NAMES
				lowerCAmelCase__					    =    PRETRAINED_VOCAB_FILES_MAP
				lowerCAmelCase__					    =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				lowerCAmelCase__					    =    ["""input_ids""", """attention_mask"""]
				lowerCAmelCase__					    =    BlenderbotTokenizer

				def __init__(							self  :  int  ,       _lowerCAmelCase  :  List[Any]=None  ,       _lowerCAmelCase  :  Optional[Any]=None  ,       _lowerCAmelCase  :  Optional[int]=None  ,       _lowerCAmelCase  :  Dict="replace"  ,       _lowerCAmelCase  :  Dict="<s>"  ,       _lowerCAmelCase  :  str="</s>"  ,       _lowerCAmelCase  :  Optional[Any]="</s>"  ,       _lowerCAmelCase  :  int="<s>"  ,       _lowerCAmelCase  :  Optional[Any]="<unk>"  ,       _lowerCAmelCase  :  Tuple="<pad>"  ,       _lowerCAmelCase  :  Dict="<mask>"  ,       _lowerCAmelCase  :  Union[str, Any]=False  ,       _lowerCAmelCase  :  Optional[int]=True  ,       **_lowerCAmelCase  :  Tuple  ,       ):







											'''simple docstring'''

											super().__init__(
											    __UpperCamelCase  ,       __UpperCamelCase  ,       tokenizer_file=__UpperCamelCase  ,       errors=__UpperCamelCase  ,       bos_token=__UpperCamelCase  ,       eos_token=__UpperCamelCase  ,       sep_token=__UpperCamelCase  ,       cls_token=__UpperCamelCase  ,       unk_token=__UpperCamelCase  ,       pad_token=__UpperCamelCase  ,       mask_token=__UpperCamelCase  ,       add_prefix_space=__UpperCamelCase  ,       trim_offsets=__UpperCamelCase  ,       **__UpperCamelCase  ,       )

											__lowercase       	=json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__())
											if pre_tok_state.get('add_prefix_space'  ,       __UpperCamelCase) != add_prefix_space:
																		__lowercase       	=getattr(__UpperCamelCase  ,       pre_tok_state.pop('type'))
																		__lowercase       	=add_prefix_space
																		__lowercase       	=pre_tok_class(**__UpperCamelCase)

											__lowercase       	=add_prefix_space

											__lowercase       	='post_processor'
											__lowercase       	=getattr(self.backend_tokenizer  ,       __UpperCamelCase  ,       __UpperCamelCase)
											if tokenizer_component_instance:
																		__lowercase       	=json.loads(tokenizer_component_instance.__getstate__())

																		# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
																		if "sep" in state:
																									__lowercase       	=tuple(state['sep'])
																		if "cls" in state:
																									__lowercase       	=tuple(state['cls'])

																		__lowercase       	=False

																		if state.get('add_prefix_space'  ,       __UpperCamelCase) != add_prefix_space:
																									__lowercase       	=add_prefix_space
																									__lowercase       	=True

																		if state.get('trim_offsets'  ,       __UpperCamelCase) != trim_offsets:
																									__lowercase       	=trim_offsets
																									__lowercase       	=True

																		if changes_to_apply:
																									__lowercase       	=getattr(__UpperCamelCase  ,       state.pop('type'))
																									__lowercase       	=component_class(**__UpperCamelCase)
																									setattr(self.backend_tokenizer  ,       __UpperCamelCase  ,       __UpperCamelCase)

				@property
				# Copied from transformers.models.roberta.tokenization_roberta_fast.RobertaTokenizerFast.mask_token with Roberta->Blenderbot, RoBERTa->Blenderbot
				def 				__lowerCamelCase     (							self  :  Any):







											'''simple docstring'''

											if self._mask_token is None:
																		if self.verbose:
																									logger.error('Using mask_token, but it is not set yet.')
																		return None
											return str(self._mask_token)

				@mask_token.setter
				def 				__lowerCamelCase     (							self  :  Optional[int]  ,       _lowerCAmelCase  :  Dict):







											'''simple docstring'''

											__lowercase       	=AddedToken(__UpperCamelCase  ,       lstrip=__UpperCamelCase  ,       rstrip=__UpperCamelCase) if isinstance(__UpperCamelCase  ,       __UpperCamelCase) else value
											__lowercase       	=value

				def 				__lowerCamelCase     (							self  :  List[str]  ,       *_lowerCAmelCase  :  Union[str, Any]  ,       **_lowerCAmelCase  :  Union[str, Any]):







											'''simple docstring'''

											__lowercase       	=kwargs.get('is_split_into_words'  ,       __UpperCamelCase)
											assert self.add_prefix_space or not is_split_into_words, (
											    f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
											    "to use it with pretokenized inputs."
											)

											return super()._batch_encode_plus(*__UpperCamelCase  ,       **__UpperCamelCase)

				def 				__lowerCamelCase     (							self  :  Optional[Any]  ,       *_lowerCAmelCase  :  Tuple  ,       **_lowerCAmelCase  :  Tuple):







											'''simple docstring'''

											__lowercase       	=kwargs.get('is_split_into_words'  ,       __UpperCamelCase)

											assert self.add_prefix_space or not is_split_into_words, (
											    f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
											    "to use it with pretokenized inputs."
											)

											return super()._encode_plus(*__UpperCamelCase  ,       **__UpperCamelCase)

				def 				__lowerCamelCase     (							self  :  Any  ,       _lowerCAmelCase  :  str  ,       _lowerCAmelCase  :  Optional[str] = None):







											'''simple docstring'''

											__lowercase       	=self._tokenizer.model.save(__UpperCamelCase  ,       name=__UpperCamelCase)
											return tuple(__UpperCamelCase)

				def 				__lowerCamelCase     (							self  :  int  ,       _lowerCAmelCase  :  List[int]  ,       _lowerCAmelCase  :  Optional[List[int]] = None):







											'''simple docstring'''

											__lowercase       	=[self.sep_token_id]
											__lowercase       	=[self.cls_token_id]

											if token_ids_a is None:
																		return len(cls + token_ids_a + sep) * [0]
											return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0]

				def 				__lowerCamelCase     (							self  :  Tuple  ,       _lowerCAmelCase  :  List[int]  ,       _lowerCAmelCase  :  Optional[List[int]] = None):







											'''simple docstring'''

											return token_ids_a + [self.eos_token_id]

				def 				__lowerCamelCase     (							self  :  Tuple  ,       _lowerCAmelCase  :  "Conversation"):







											'''simple docstring'''

											__lowercase       	=[]
											for is_user, text in conversation.iter_texts():
																		if is_user:
																									# We need to space prefix as it's being done within blenderbot
																									inputs.append(' ' + text)
																		else:
																									# Generated responses should contain them already.
																									inputs.append(__UpperCamelCase)

											__lowercase       	='  '.join(__UpperCamelCase)
											__lowercase       	=self.encode(__UpperCamelCase)
											if len(__UpperCamelCase) > self.model_max_length:
																		__lowercase       	=input_ids[-self.model_max_length :]
																		logger.warning(f"""Trimmed input from conversation as it was longer than {self.model_max_length} tokens.""")
											return input_ids








'''simple docstring'''



import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class _UpperCamelCase		(     A      ,       A      ,       A      ,       unittest.TestCase		):





				'''simple docstring'''





				lowerCAmelCase__					    =    AltDiffusionPipeline
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_PARAMS
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_BATCH_PARAMS
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_IMAGE_PARAMS

				def 				__lowerCamelCase     (							self  :  Union[str, Any]):







											'''simple docstring'''

											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  ,       )
											__lowercase       	=DDIMScheduler(
											    beta_start=0.0_0085  ,       beta_end=0.012  ,       beta_schedule='scaled_linear'  ,       clip_sample=_lowerCAmelCase  ,       set_alpha_to_one=_lowerCAmelCase  ,       )
											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  ,       )

											# TODO: address the non-deterministic text encoder (fails for save-load tests)
											# torch.manual_seed(0)
											# text_encoder_config = RobertaSeriesConfig(
											#     hidden_size=32,
											#     project_dim=32,
											#     intermediate_size=37,
											#     layer_norm_eps=1e-05,
											#     num_attention_heads=4,
											#     num_hidden_layers=5,
											#     vocab_size=5002,
											# )
											# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

											torch.manual_seed(0)
											__lowercase       	=CLIPTextConfig(
											    bos_token_id=0  ,       eos_token_id=2  ,       hidden_size=3_2  ,       projection_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_2  ,       )
											__lowercase       	=CLIPTextModel(_lowerCAmelCase)

											__lowercase       	=XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta')
											__lowercase       	=7_7

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

				def 				__lowerCamelCase     (							self  :  List[Any]  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  Dict=0):







											'''simple docstring'''

											if str(_lowerCAmelCase).startswith('mps'):
																		__lowercase       	=torch.manual_seed(_lowerCAmelCase)
											else:
																		__lowercase       	=torch.Generator(device=_lowerCAmelCase).manual_seed(_lowerCAmelCase)
											__lowercase       	={
											    'prompt': 'A painting of a squirrel eating a burger',
											    'generator': generator,
											    'num_inference_steps': 2,
											    'guidance_scale': 6.0,
											    'output_type': 'numpy',
											}
											return inputs

				def 				__lowerCamelCase     (							self  :  List[str]):







											'''simple docstring'''

											super().test_attention_slicing_forward_pass(expected_max_diff=3e-3)

				def 				__lowerCamelCase     (							self  :  Optional[int]):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Optional[Any]):







											'''simple docstring'''

											__lowercase       	='cpu'  # ensure determinism for the device-dependent torch.Generator

											__lowercase       	=self.get_dummy_components()
											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  ,       vocab_size=5_0_0_2  ,       )
											# TODO: remove after fixing the non-deterministic text encoder
											__lowercase       	=RobertaSeriesModelWithTransformation(_lowerCAmelCase)
											__lowercase       	=text_encoder

											__lowercase       	=AltDiffusionPipeline(**_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	=self.get_dummy_inputs(_lowerCAmelCase)
											__lowercase       	='A photo of an astronaut'
											__lowercase       	=alt_pipe(**_lowerCAmelCase)
											__lowercase       	=output.images
											__lowercase       	=image[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__lowercase       	=np.array(
											    [0.574_8162, 0.6044_7145, 0.4882_1217, 0.5010_0636, 0.543_1185, 0.4576_3683, 0.4965_7696, 0.4813_2733, 0.4757_3093])

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

				def 				__lowerCamelCase     (							self  :  str):







											'''simple docstring'''

											__lowercase       	='cpu'  # ensure determinism for the device-dependent torch.Generator

											__lowercase       	=self.get_dummy_components()
											__lowercase       	=PNDMScheduler(skip_prk_steps=_lowerCAmelCase)
											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  ,       vocab_size=5_0_0_2  ,       )
											# TODO: remove after fixing the non-deterministic text encoder
											__lowercase       	=RobertaSeriesModelWithTransformation(_lowerCAmelCase)
											__lowercase       	=text_encoder
											__lowercase       	=AltDiffusionPipeline(**_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	=self.get_dummy_inputs(_lowerCAmelCase)
											__lowercase       	=alt_pipe(**_lowerCAmelCase)
											__lowercase       	=output.images
											__lowercase       	=image[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__lowercase       	=np.array(
											    [0.5160_5093, 0.570_7241, 0.4736_5507, 0.5057_8886, 0.563_3877, 0.464_2503, 0.518_2081, 0.4876_3484, 0.4908_4237])

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





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





				'''simple docstring'''





				def 				__lowerCamelCase     (							self  :  str):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Union[str, Any]):







											'''simple docstring'''

											__lowercase       	=AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'  ,       safety_checker=_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	='A painting of a squirrel eating a burger'
											__lowercase       	=torch.manual_seed(0)
											__lowercase       	=alt_pipe([prompt]  ,       generator=_lowerCAmelCase  ,       guidance_scale=6.0  ,       num_inference_steps=2_0  ,       output_type='np')

											__lowercase       	=output.images

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__lowercase       	=np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586])

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

				def 				__lowerCamelCase     (							self  :  Dict):







											'''simple docstring'''

											__lowercase       	=DDIMScheduler.from_pretrained('BAAI/AltDiffusion'  ,       subfolder='scheduler')

											__lowercase       	=AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'  ,       scheduler=_lowerCAmelCase  ,       safety_checker=_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	='A painting of a squirrel eating a burger'
											__lowercase       	=torch.manual_seed(0)

											__lowercase       	=alt_pipe([prompt]  ,       generator=_lowerCAmelCase  ,       num_inference_steps=2  ,       output_type='numpy')
											__lowercase       	=output.images

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__lowercase       	=np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323])

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



