




'''simple docstring'''






import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
      from test_module.custom_tokenization_fast import CustomTokenizerFast






class        lowercase_      (						unittest.TestCase							):





     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           snake_case__       :   List[str]	      =    mock.Mock()
           snake_case__       :   int	      =    500
           snake_case__       :   int	      =    {}
           snake_case__       :   Tuple	      =    HTTPError
           snake_case__       :   List[str]	      =    {}

           # Download this model to make sure it's in the cache.
           snake_case__       :   Dict	      =    BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'			)

           # Under the mock environment we get a 500 error when trying to reach the tokenizer.
           with mock.patch('requests.Session.request'     ,							return_value=A_			) as mock_head:
                 snake_case__       :   Any	      =    BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'			)
                 # This check we did call the fake head request
                 mock_head.assert_called()





     @require_tokenizers
     def 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           snake_case__       :   Optional[int]	      =    mock.Mock()
           snake_case__       :   Dict	      =    500
           snake_case__       :   int	      =    {}
           snake_case__       :   Union[str, Any]	      =    HTTPError
           snake_case__       :   Tuple	      =    {}

           # Download this model to make sure it's in the cache.
           snake_case__       :   str	      =    GPTaTokenizerFast.from_pretrained('gpt2'			)

           # Under the mock environment we get a 500 error when trying to reach the tokenizer.
           with mock.patch('requests.Session.request'     ,							return_value=A_			) as mock_head:
                 snake_case__       :   Any	      =    GPTaTokenizerFast.from_pretrained('gpt2'			)
                 # This check we did call the fake head request
                 mock_head.assert_called()





     def 			_lowerCAmelCase      (     self     :					Tuple			):






           try:
                 snake_case__       :   Any	      =    tempfile.mktemp()
                 with open(A_     ,							'wb'			) as f:
                       http_get('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'     ,							A_			)

                 snake_case__       :   Optional[int]	      =    AlbertTokenizer.from_pretrained(A_			)
           finally:
                 os.remove(A_			)

           # Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
           # the current folder and have the right name.
           if os.path.isfile('tokenizer.json'			):
                 # We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
                 return
           try:
                 with open('tokenizer.json'     ,							'wb'			) as f:
                       http_get('https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json'     ,							A_			)
                 snake_case__       :   int	      =    AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)
                 # The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
                 self.assertEqual(tokenizer.vocab_size     ,							1000			)
                 # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

           finally:
                 os.remove('tokenizer.json'			)





     def 			_lowerCAmelCase      (     self     :					Any			):
           snake_case__       :   List[str]	      =    AlbertTokenizer.from_pretrained('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'			)






@is_staging_test
class        lowercase_      (						unittest.TestCase							):
     A_											=			["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					int			):
           snake_case__       :   Any	      =    TOKEN
           HfFolder.save_token(A_			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[Any]			):






           try:
                 delete_repo(token=cls._token     ,							repo_id='test-tokenizer'			)
           except HTTPError:
                 pass

           try:
                 delete_repo(token=cls._token     ,							repo_id='valid_org/test-tokenizer-org'			)
           except HTTPError:
                 pass

           try:
                 delete_repo(token=cls._token     ,							repo_id='test-dynamic-tokenizer'			)
           except HTTPError:
                 pass





     def 			_lowerCAmelCase      (     self     :					Dict			):






           with tempfile.TemporaryDirectory() as tmp_dir:
                 snake_case__       :   List[str]	      =    os.path.join(A_     ,							'vocab.txt'			)
                 with open(A_     ,							'w'     ,							encoding='utf-8'			) as vocab_writer:
                       vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]			)			)
                 snake_case__       :   Union[str, Any]	      =    BertTokenizer(A_			)

           tokenizer.push_to_hub('test-tokenizer'     ,							use_auth_token=self._token			)
           snake_case__       :   Union[str, Any]	      =    BertTokenizer.from_pretrained(F"{USER}/test-tokenizer"			)
           self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab			)

           # Reset repo
           delete_repo(token=self._token     ,							repo_id='test-tokenizer'			)

           # Push to hub via save_pretrained
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(A_     ,							repo_id='test-tokenizer'     ,							push_to_hub=A_     ,							use_auth_token=self._token			)

           snake_case__       :   List[Any]	      =    BertTokenizer.from_pretrained(F"{USER}/test-tokenizer"			)
           self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab			)





     def 			_lowerCAmelCase      (     self     :					int			):






           with tempfile.TemporaryDirectory() as tmp_dir:
                 snake_case__       :   Dict	      =    os.path.join(A_     ,							'vocab.txt'			)
                 with open(A_     ,							'w'     ,							encoding='utf-8'			) as vocab_writer:
                       vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]			)			)
                 snake_case__       :   Optional[int]	      =    BertTokenizer(A_			)

           tokenizer.push_to_hub('valid_org/test-tokenizer-org'     ,							use_auth_token=self._token			)
           snake_case__       :   int	      =    BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'			)
           self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab			)

           # Reset repo
           delete_repo(token=self._token     ,							repo_id='valid_org/test-tokenizer-org'			)

           # Push to hub via save_pretrained
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(
                     A_     ,							repo_id='valid_org/test-tokenizer-org'     ,							push_to_hub=A_     ,							use_auth_token=self._token			)

           snake_case__       :   Dict	      =    BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'			)
           self.assertDictEqual(new_tokenizer.vocab     ,							tokenizer.vocab			)





     @require_tokenizers
     def 			_lowerCAmelCase      (     self     :					Any			):
           CustomTokenizer.register_for_auto_class()
           with tempfile.TemporaryDirectory() as tmp_dir:
                 snake_case__       :   List[str]	      =    os.path.join(A_     ,							'vocab.txt'			)
                 with open(A_     ,							'w'     ,							encoding='utf-8'			) as vocab_writer:
                       vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]			)			)
                 snake_case__       :   List[Any]	      =    CustomTokenizer(A_			)

           # No fast custom tokenizer
           tokenizer.push_to_hub('test-dynamic-tokenizer'     ,							use_auth_token=self._token			)

           snake_case__       :   Optional[int]	      =    AutoTokenizer.from_pretrained(F"{USER}/test-dynamic-tokenizer"     ,							trust_remote_code=A_			)
           # Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
           self.assertEqual(tokenizer.__class__.__name__     ,							'CustomTokenizer'			)

           # Fast and slow custom tokenizer
           CustomTokenizerFast.register_for_auto_class()
           with tempfile.TemporaryDirectory() as tmp_dir:
                 snake_case__       :   List[str]	      =    os.path.join(A_     ,							'vocab.txt'			)
                 with open(A_     ,							'w'     ,							encoding='utf-8'			) as vocab_writer:
                       vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]			)			)

                 snake_case__       :   Any	      =    BertTokenizerFast.from_pretrained(A_			)
                 bert_tokenizer.save_pretrained(A_			)
                 snake_case__       :   Dict	      =    CustomTokenizerFast.from_pretrained(A_			)

           tokenizer.push_to_hub('test-dynamic-tokenizer'     ,							use_auth_token=self._token			)

           snake_case__       :   Any	      =    AutoTokenizer.from_pretrained(F"{USER}/test-dynamic-tokenizer"     ,							trust_remote_code=A_			)
           # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
           self.assertEqual(tokenizer.__class__.__name__     ,							'CustomTokenizerFast'			)
           snake_case__       :   Any	      =    AutoTokenizer.from_pretrained(
               F"{USER}/test-dynamic-tokenizer"     ,							use_fast=A_     ,							trust_remote_code=A_			)
           # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
           self.assertEqual(tokenizer.__class__.__name__     ,							'CustomTokenizer'			)






class        lowercase_      (						unittest.TestCase							):





     def 			_lowerCAmelCase      (     self     :					Optional[Any]			):
           snake_case__       :   Optional[Any]	      =    Trie()
           trie.add('Hello 友達'			)
           self.assertEqual(trie.data     ,							{'H': {'e': {'l': {'l': {'o': {' ': {'友': {'達': {'': 1}}}}}}}}}			)
           trie.add('Hello'			)
           trie.data
           self.assertEqual(trie.data     ,							{'H': {'e': {'l': {'l': {'o': {'': 1, ' ': {'友': {'達': {'': 1}}}}}}}}}			)





     def 			_lowerCAmelCase      (     self     :					str			):
           snake_case__       :   Optional[Any]	      =    Trie()
           self.assertEqual(trie.split('[CLS] This is a extra_id_100'			)     ,							['[CLS] This is a extra_id_100']			)
           trie.add('[CLS]'			)
           trie.add('extra_id_1'			)
           trie.add('extra_id_100'			)
           self.assertEqual(trie.split('[CLS] This is a extra_id_100'			)     ,							['[CLS]', ' This is a ', 'extra_id_100']			)





     def 			_lowerCAmelCase      (     self     :					str			):
           snake_case__       :   Dict	      =    Trie()
           trie.add('A'			)
           self.assertEqual(trie.split('ABC'			)     ,							['A', 'BC']			)
           self.assertEqual(trie.split('BCA'			)     ,							['BC', 'A']			)





     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           snake_case__       :   Dict	      =    Trie()
           trie.add('TOKEN]'			)
           trie.add('[SPECIAL_TOKEN]'			)
           self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'			)     ,							['This is something ', '[SPECIAL_TOKEN]']			)





     def 			_lowerCAmelCase      (     self     :					Optional[Any]			):
           snake_case__       :   int	      =    Trie()
           trie.add('A'			)
           trie.add('P'			)
           trie.add('[SPECIAL_TOKEN]'			)
           self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'			)     ,							['This is something ', '[SPECIAL_TOKEN]']			)





     def 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           snake_case__       :   List[Any]	      =    Trie()
           trie.add('AB'			)
           trie.add('B'			)
           trie.add('C'			)
           self.assertEqual(trie.split('ABC'			)     ,							['AB', 'C']			)





     def 			_lowerCAmelCase      (     self     :					Dict			):
           snake_case__       :   Union[str, Any]	      =    Trie()
           trie.add('ABC'			)
           trie.add('B'			)
           trie.add('CD'			)
           self.assertEqual(trie.split('ABCD'			)     ,							['ABC', 'D']			)





     def 			_lowerCAmelCase      (     self     :					Optional[int]			):
           snake_case__       :   Any	      =    Trie()
           snake_case__       :   Any	      =    trie.cut_text('ABC'     ,							[0, 0, 2, 1, 2, 3]			)
           self.assertEqual(A_     ,							['AB', 'C']			)


'''simple docstring'''
from typing import Callable, List, Optional, Tuple, Union

import torch
from transformers import CLIPTextModel, CLIPTokenizer

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin, TransformeraDModel, VQModel
from ...schedulers import VQDiffusionScheduler
from ...utils import logging
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


lowerCAmelCase					:    Optional[Any]           = logging.get_logger(__name__)  # pylint: disable=invalid-name


class 			SCREAMING_SNAKE_CASE__      (     snake_case_							,       snake_case_):







				@register_to_config
				def __init__(       self						,				A_						,				A_ = None						,				A_ = None     )->		Tuple:







											'''simple docstring'''






											super().__init__()

											UpperCamelCase   			=     learnable

											if self.learnable:
																		assert hidden_size is not None, "learnable=True requires `hidden_size` to be set"
																		assert length is not None, "learnable=True requires `length` to be set"

																		UpperCamelCase   			=     torch.zeros(A_						,				A_     )
											else:
																		UpperCamelCase   			=     None

											UpperCamelCase   			=     torch.nn.Parameter(A_     )


class 			SCREAMING_SNAKE_CASE__      (     snake_case_):
				lowerCAmelCase_     			=							42
				lowerCAmelCase_     			=							42
				lowerCAmelCase_     			=							42
				lowerCAmelCase_     			=							42
				lowerCAmelCase_     			=							42
				lowerCAmelCase_     			=							42







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







											'''simple docstring'''






											super().__init__()

											self.register_modules(
											    vqvae=A_						,				transformer=A_						,				text_encoder=A_						,				tokenizer=A_						,				scheduler=A_						,				learned_classifier_free_sampling_embeddings=A_						,				)







				def 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_     )->		Tuple:







											'''simple docstring'''






											UpperCamelCase   			=     len(A_     ) if isinstance(A_						,				A_     ) else 1

											# get prompt text embeddings
											UpperCamelCase   			=     self.tokenizer(
											    A_						,				padding='max_length'						,				max_length=self.tokenizer.model_max_length						,				return_tensors='pt'						,				)
											UpperCamelCase   			=     text_inputs.input_ids

											if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
																		UpperCamelCase   			=     self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]     )
																		logger.warning(
																		    'The following part of your input was truncated because CLIP can only handle sequences up to'
																		    F''' {self.tokenizer.model_max_length} tokens: {removed_text}'''     )
																		UpperCamelCase   			=     text_input_ids[:, : self.tokenizer.model_max_length]
											UpperCamelCase   			=     self.text_encoder(text_input_ids.to(self.device     )     )[0]

											# NOTE: This additional step of normalizing the text embeddings is from VQ-Diffusion.
											# While CLIP does normalize the pooled output of the text transformer when combining
											# the image and text embeddings, CLIP does not directly normalize the last hidden state.
											#
											# CLIP normalizing the pooled output.
											# https://github.com/huggingface/transformers/blob/d92e22d1f28324f513f3080e5c47c071a3916721/src/transformers/models/clip/modeling_clip.py#L1052-L1053
											UpperCamelCase   			=     prompt_embeds / prompt_embeds.norm(dim=-1						,				keepdim=A_     )

											# duplicate text embeddings for each generation per prompt
											UpperCamelCase   			=     prompt_embeds.repeat_interleave(A_						,				dim=0     )

											if do_classifier_free_guidance:
																		if self.learned_classifier_free_sampling_embeddings.learnable:
																									UpperCamelCase   			=     self.learned_classifier_free_sampling_embeddings.embeddings
																									UpperCamelCase   			=     negative_prompt_embeds.unsqueeze(0     ).repeat(A_						,				1						,				1     )
																		else:
																									UpperCamelCase   			=     [''] * batch_size

																									UpperCamelCase   			=     text_input_ids.shape[-1]
																									UpperCamelCase   			=     self.tokenizer(
																									    A_						,				padding='max_length'						,				max_length=A_						,				truncation=A_						,				return_tensors='pt'						,				)
																									UpperCamelCase   			=     self.text_encoder(uncond_input.input_ids.to(self.device     )     )[0]
																									# See comment for normalizing text embeddings
																									UpperCamelCase   			=     negative_prompt_embeds / negative_prompt_embeds.norm(dim=-1						,				keepdim=A_     )

																		# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
																		UpperCamelCase   			=     negative_prompt_embeds.shape[1]
																		UpperCamelCase   			=     negative_prompt_embeds.repeat(1						,				A_						,				1     )
																		UpperCamelCase   			=     negative_prompt_embeds.view(batch_size * num_images_per_prompt						,				A_						,				-1     )

																		# For classifier free guidance, we need to do two forward passes.
																		# Here we concatenate the unconditional and text embeddings into a single batch
																		# to avoid doing two forward passes
																		UpperCamelCase   			=     torch.cat([negative_prompt_embeds, prompt_embeds]     )

											return prompt_embeds







				@torch.no_grad()
				def __call__(       self						,				A_						,				A_ = 100						,				A_ = 5.0						,				A_ = 1.0						,				A_ = 1						,				A_ = None						,				A_ = None						,				A_ = "pil"						,				A_ = True						,				A_ = None						,				A_ = 1						,				)->		Union[ImagePipelineOutput, Tuple]:







											'''simple docstring'''






											if isinstance(A_						,				A_     ):
																		UpperCamelCase   			=     1
											elif isinstance(A_						,				A_     ):
																		UpperCamelCase   			=     len(A_     )
											else:
																		raise ValueError(F'''`prompt` has to be of type `str` or `list` but is {type(A_     )}'''     )

											UpperCamelCase   			=     batch_size * num_images_per_prompt

											UpperCamelCase   			=     guidance_scale > 1.0

											UpperCamelCase   			=     self._encode_prompt(A_						,				A_						,				A_     )

											if (callback_steps is None) or (
											    callback_steps is not None and (not isinstance(A_						,				A_     ) or callback_steps <= 0)
											):
																		raise ValueError(
																		    F'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
																		    F''' {type(A_     )}.'''     )

											# get the initial completely masked latents unless the user supplied it

											UpperCamelCase   			=     (batch_size, self.transformer.num_latent_pixels)
											if latents is None:
																		UpperCamelCase   			=     self.transformer.num_vector_embeds - 1
																		UpperCamelCase   			=     torch.full(A_						,				A_     ).to(self.device     )
											else:
																		if latents.shape != latents_shape:
																									raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''     )
																		if (latents < 0).any() or (latents >= self.transformer.num_vector_embeds).any():
																									raise ValueError(
																									    'Unexpected latents value(s). All latents be valid embedding indices i.e. in the range 0,'
																									    F''' {self.transformer.num_vector_embeds - 1} (inclusive).'''     )
																		UpperCamelCase   			=     latents.to(self.device     )

											# set timesteps
											self.scheduler.set_timesteps(A_						,				device=self.device     )

											UpperCamelCase   			=     self.scheduler.timesteps.to(self.device     )

											UpperCamelCase   			=     latents

											for i, t in enumerate(self.progress_bar(A_     )     ):
																		# expand the sample if we are doing classifier free guidance
																		UpperCamelCase   			=     torch.cat([sample] * 2     ) if do_classifier_free_guidance else sample

																		# predict the un-noised image
																		# model_output == `log_p_x_0`
																		UpperCamelCase   			=     self.transformer(A_						,				encoder_hidden_states=A_						,				timestep=A_     ).sample

																		if do_classifier_free_guidance:
																									UpperCamelCase			,	UpperCamelCase   			=     model_output.chunk(2     )
																									UpperCamelCase   			=     model_output_uncond + guidance_scale * (model_output_text - model_output_uncond)
																									model_output -= torch.logsumexp(A_						,				dim=1						,				keepdim=A_     )

																		UpperCamelCase   			=     self.truncate(A_						,				A_     )

																		# remove `log(0)`'s (`-inf`s)
																		UpperCamelCase   			=     model_output.clamp(-70     )

																		# compute the previous noisy sample x_t -> x_t-1
																		UpperCamelCase   			=     self.scheduler.step(A_						,				timestep=A_						,				sample=A_						,				generator=A_     ).prev_sample

																		# call the callback, if provided
																		if callback is not None and i % callback_steps == 0:
																									callback(A_						,				A_						,				A_     )

											UpperCamelCase   			=     self.vqvae.config.vq_embed_dim
											UpperCamelCase   			=     (batch_size, self.transformer.height, self.transformer.width, embedding_channels)
											UpperCamelCase   			=     self.vqvae.quantize.get_codebook_entry(A_						,				shape=A_     )
											UpperCamelCase   			=     self.vqvae.decode(A_						,				force_not_quantize=A_     ).sample

											UpperCamelCase   			=     (image / 2 + 0.5).clamp(0						,				1     )
											UpperCamelCase   			=     image.cpu().permute(0						,				2						,				3						,				1     ).numpy()

											if output_type == "pil":
																		UpperCamelCase   			=     self.numpy_to_pil(A_     )

											if not return_dict:
																		return (image,)

											return ImagePipelineOutput(images=A_     )







				def 						UpperCAmelCase_    (       self						,				A_						,				A_     )->		torch.FloatTensor:







											'''simple docstring'''






											UpperCamelCase			,	UpperCamelCase   			=     torch.sort(A_						,				1						,				descending=A_     )
											UpperCamelCase   			=     torch.exp(A_     )
											UpperCamelCase   			=     sorted_p_x_0.cumsum(dim=1     ) < truncation_rate

											# Ensure that at least the largest probability is not zeroed out
											UpperCamelCase   			=     torch.full_like(keep_mask[:, 0:1, :]						,				A_     )
											UpperCamelCase   			=     torch.cat((all_true, keep_mask)						,				dim=1     )
											UpperCamelCase   			=     keep_mask[:, :-1, :]

											UpperCamelCase   			=     keep_mask.gather(1						,				indices.argsort(1     )     )

											UpperCamelCase   			=     log_p_x_0.clone()

											UpperCamelCase   			=     -torch.inf  # -inf = log(0)

											return rv




