


import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



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

   '''simple docstring'''







   a_				:							Union[str, Any]    = IFImgaImgSuperResolutionPipeline
   a_				:							Union[str, Any]    = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
   a_				:							List[str]    = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"}						)
   a_				:							Optional[Any]    = PipelineTesterMixin.required_optional_params - {"latents"}

   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         return self._get_superresolution_dummy_components()

   def   _snake_case    (  self  : Optional[int]       ,  _lowerCamelCase  : Optional[Any]       ,  _lowerCamelCase  : Dict=0							):






         '''simple docstring'''



         if str(_lowerCamelCase							).startswith("""mps"""							):
               __lowerCamelCase     :      str       						=						torch.manual_seed(_lowerCamelCase							)
         else:
               __lowerCamelCase     :      Tuple       						=						torch.Generator(device=_lowerCamelCase							).manual_seed(_lowerCamelCase							)

         __lowerCamelCase     :      Optional[int]       						=						floats_tensor((1, 3, 3_2, 3_2)       ,  rng=random.Random(_lowerCamelCase							)							).to(_lowerCamelCase							)
         __lowerCamelCase     :      Dict       						=						floats_tensor((1, 3, 1_6, 1_6)       ,  rng=random.Random(_lowerCamelCase							)							).to(_lowerCamelCase							)

         __lowerCamelCase     :      Optional[Any]       						=						{
             """prompt""": """A painting of a squirrel eating a burger""",
             """image""": image,
             """original_image""": original_image,
             """generator""": generator,
             """num_inference_steps""": 2,
             """output_type""": """numpy""",
         }

         return inputs

   @unittest.skipIf(
       torch_device != """cuda""" or not is_xformers_available()       ,  reason="""XFormers attention is only available with CUDA and `xformers` installed"""       ,  )
   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3							)

   def   _snake_case    (  self  : Dict							):






         '''simple docstring'''



         self._test_save_load_optional_components()

   @unittest.skipIf(torch_device != """cuda"""       ,  reason="""float16 requires CUDA"""							)
   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         super().test_save_load_floataa(expected_max_diff=1E-1							)

   def   _snake_case    (  self  : Dict							):






         '''simple docstring'''



         self._test_attention_slicing_forward_pass(expected_max_diff=1E-2							)

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         self._test_save_load_local()


   def   _snake_case    (  self  : List[Any]							):






         '''simple docstring'''



         self._test_inference_batch_single_identical(
             expected_max_diff=1E-2       ,  )







import json
from typing import Iterator, List, Union

from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
from tokenizers.implementations.base_tokenizer import BaseTokenizer
from tokenizers.models import Unigram
from tokenizers.processors import TemplateProcessing



class 							_UpperCamelCase (						A						):

   '''simple docstring'''







   def __init__(  self  : str       ,  _lowerCamelCase  : str = "▁"       ,  _lowerCamelCase  : bool = True       ,  _lowerCamelCase  : Union[str, AddedToken] = "<unk>"       ,  _lowerCamelCase  : Union[str, AddedToken] = "</s>"       ,  _lowerCamelCase  : Union[str, AddedToken] = "<pad>"       ,  ):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						{
             """pad""": {"""id""": 0, """token""": pad_token},
             """eos""": {"""id""": 1, """token""": eos_token},
             """unk""": {"""id""": 2, """token""": unk_token},
         }

         __lowerCamelCase     :      Optional[Any]       						=						[None] * len(self.special_tokens							)
         for token_dict in self.special_tokens.values():
               __lowerCamelCase     :      Tuple       						=						token_dict["""token"""]

         __lowerCamelCase     :      Optional[int]       						=						Tokenizer(Unigram()							)

         __lowerCamelCase     :      str       						=						normalizers.Sequence(
             [
                 normalizers.Nmt(),
                 normalizers.NFKC(),
                 normalizers.Replace(Regex(""" {2,}"""							)       ,  """ """							),
                 normalizers.Lowercase(),
             ]							)
         __lowerCamelCase     :      int       						=						pre_tokenizers.Sequence(
             [
                 pre_tokenizers.Metaspace(replacement=_lowerCamelCase       ,  add_prefix_space=_lowerCamelCase							),
                 pre_tokenizers.Digits(individual_digits=_lowerCamelCase							),
                 pre_tokenizers.Punctuation(),
             ]							)
         __lowerCamelCase     :      Tuple       						=						decoders.Metaspace(replacement=_lowerCamelCase       ,  add_prefix_space=_lowerCamelCase							)

         __lowerCamelCase     :      Tuple       						=						TemplateProcessing(
             single=F"""$A {self.special_tokens["eos"]["token"]}"""       ,  special_tokens=[(self.special_tokens["""eos"""]["""token"""], self.special_tokens["""eos"""]["""id"""])]       ,  )

         __lowerCamelCase     :      Tuple       						=						{
             """model""": """SentencePieceUnigram""",
             """replacement""": replacement,
             """add_prefix_space""": add_prefix_space,
         }

         super().__init__(_lowerCamelCase       ,  _lowerCamelCase							)

   def   _snake_case    (  self  : Dict       ,  _lowerCamelCase  : Union[str, List[str]]       ,  _lowerCamelCase  : int = 8_0_0_0       ,  _lowerCamelCase  : bool = True       ,  ):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						trainers.UnigramTrainer(
             vocab_size=_lowerCamelCase       ,  special_tokens=self.special_tokens_list       ,  show_progress=_lowerCamelCase       ,  )

         if isinstance(_lowerCamelCase       ,  _lowerCamelCase							):
               __lowerCamelCase     :      Optional[int]       						=						[files]
         self._tokenizer.train(_lowerCamelCase       ,  trainer=_lowerCamelCase							)

         self.add_unk_id()

   def   _snake_case    (  self  : List[Any]       ,  _lowerCamelCase  : Union[Iterator[str], Iterator[Iterator[str]]]       ,  _lowerCamelCase  : int = 8_0_0_0       ,  _lowerCamelCase  : bool = True       ,  ):






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						trainers.UnigramTrainer(
             vocab_size=_lowerCamelCase       ,  special_tokens=self.special_tokens_list       ,  show_progress=_lowerCamelCase       ,  )

         self._tokenizer.train_from_iterator(_lowerCamelCase       ,  trainer=_lowerCamelCase							)

         self.add_unk_id()


   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      List[str]       						=						json.loads(self._tokenizer.to_str()							)

         __lowerCamelCase     :      Optional[int]       						=						self.special_tokens["""unk"""]["""id"""]

         __lowerCamelCase     :      List[str]       						=						Tokenizer.from_str(json.dumps(_lowerCamelCase							)							)



