





'''simple docstring'''


import os
from shutil import copyfile
from typing import TYPE_CHECKING, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging
from ...utils.versions import require_version


if TYPE_CHECKING:
    from transformers.pipelines.conversational import Conversation

require_version("tokenizers>=0.13.3")

if is_sentencepiece_available():
    from .tokenization_llama import LlamaTokenizer
else:
    A_				     =							None

A_				     =							logging.get_logger(__name__)
A_				     =							{"vocab_file": "tokenizer.model", "tokenizer_file": "tokenizer.json"}

A_     ,  A_				     =							"[INST]", "[/INST]"
A_     ,  A_				     =							"<<SYS>>\n", "\n<</SYS>>\n\n"

# fmt: off
A_				     =							"You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your\\nanswers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure\\nthat your responses are socially unbiased and positive in nature.\n\nIf a question does not make any sense, or is not factually coherent, explain why instead of answering something not\\ncorrect. If you don't know the answer to a question, please don't share false information."


class 		UpperCamelCase__     (       a							):
      '''simple docstring'''






      _snake_case           =				VOCAB_FILES_NAMES
      _snake_case           =				LlamaTokenizer
      _snake_case           =				'''left'''
      _snake_case           =				['''input_ids''', '''attention_mask''']




      def __init__(     self     , SCREAMING_SNAKE_CASE=None     , SCREAMING_SNAKE_CASE=None     , SCREAMING_SNAKE_CASE=False     , SCREAMING_SNAKE_CASE="<unk>"     , SCREAMING_SNAKE_CASE="<s>"     , SCREAMING_SNAKE_CASE="</s>"     , SCREAMING_SNAKE_CASE=True     , SCREAMING_SNAKE_CASE=False     , **SCREAMING_SNAKE_CASE     , )				->  Any:
        super().__init__(
            vocab_file=SCREAMING_SNAKE_CASE     , tokenizer_file=SCREAMING_SNAKE_CASE     , clean_up_tokenization_spaces=SCREAMING_SNAKE_CASE     , unk_token=SCREAMING_SNAKE_CASE     , bos_token=SCREAMING_SNAKE_CASE     , eos_token=SCREAMING_SNAKE_CASE     , **SCREAMING_SNAKE_CASE     , )
        __lowerCAmelCase		:    Optional[Any]			     =  add_bos_token
        __lowerCAmelCase		:    Tuple			     =  add_eos_token
        self.update_post_processor()

        __lowerCAmelCase		:    List[str]			     =  vocab_file
        __lowerCAmelCase		:    List[Any]			     =  False if not self.vocab_file else True




      def 	snake_case  (     self )				->  List[str]:
        __lowerCAmelCase		:    Dict			     =  self.bos_token
        __lowerCAmelCase		:    Any			     =  self.bos_token_id

        __lowerCAmelCase		:    Any			     =  self.eos_token
        __lowerCAmelCase		:    Union[str, Any]			     =  self.eos_token_id

        __lowerCAmelCase		:    int			     =  F"""{(bos+':0 ') * self.add_bos_token}$A:0{(' '+eos+':0') * self.add_eos_token}"""
        __lowerCAmelCase		:    int			     =  F"""{single}{(' '+bos+':1') * self.add_bos_token} $B:1{(' '+eos+':1') * self.add_eos_token}"""

        __lowerCAmelCase		:    Union[str, Any]			     =  []
        if self.add_bos_token:
          special_tokens.append((bos, bos_token_id) )
        if self.add_eos_token:
          special_tokens.append((eos, eos_token_id) )
        __lowerCAmelCase		:    Optional[Any]			     =  processors.TemplateProcessing(
            single=SCREAMING_SNAKE_CASE     , pair=SCREAMING_SNAKE_CASE     , special_tokens=SCREAMING_SNAKE_CASE )




      @property
      def 	snake_case  (     self )				->  str:
        return self._add_eos_token




      @property
      def 	snake_case  (     self )				->  Optional[Any]:
        return self._add_bos_token




      @add_eos_token.setter
      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE )				->  Optional[int]:
        __lowerCAmelCase		:    Union[str, Any]			     =  value
        self.update_post_processor()




      @add_bos_token.setter
      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE )				->  str:
        __lowerCAmelCase		:    List[str]			     =  value
        self.update_post_processor()




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE = None )				->  Tuple[str]:
        if not self.can_save_slow_tokenizer:
          raise ValueError(
              'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
              'tokenizer.' )

        if not os.path.isdir(SCREAMING_SNAKE_CASE ):
          logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" )
          return
        __lowerCAmelCase		:    Union[str, Any]			     =  os.path.join(
            SCREAMING_SNAKE_CASE     , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] )

        if os.path.abspath(self.vocab_file ) != os.path.abspath(SCREAMING_SNAKE_CASE ):
          copyfile(self.vocab_file     , SCREAMING_SNAKE_CASE )

        return (out_vocab_file,)







      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE )				->  Union[str, Any]:
        __lowerCAmelCase		:    int			     =  list(conversation.iter_texts() )
        if not all([is_user for is_user, msg in dialogue[::2]] ) or not all(
            [not is_user for is_user, msg in dialogue[1::2]] ):
          raise ValueError(
              'The model only supports \'user\' and \'assistant\' roles, starting with user and alternating (u/a/u/a/u...)' )

        __lowerCAmelCase		:    Optional[Any]			     =  []
        if len(conversation.past_user_inputs ) > 0:
          if not conversation.past_user_inputs[0].startswith(SCREAMING_SNAKE_CASE ) or E_SYS not in conversation.past_user_inputs[0]:
            __lowerCAmelCase		:    str			     =  (
                B_SYS + DEFAULT_SYSTEM_PROMPT + E_SYS + conversation.past_user_inputs[0]
            )
        elif not dialogue[0][1].startswith(SCREAMING_SNAKE_CASE ) or E_SYS not in dialogue[0][1]:
          __lowerCAmelCase		:    int			     =  (dialogue[0][0], B_SYS + DEFAULT_SYSTEM_PROMPT + E_SYS + dialogue[0][1])

        dialog_tokens += sum(
            [
                [self.bos_token_id]
                + self.encode(
                    F"""{B_INST} {(prompt[1]).strip()} {E_INST} {(answer[1]).strip()} """     , add_special_tokens=SCREAMING_SNAKE_CASE )
                + [self.eos_token_id]
                for prompt, answer in zip(dialogue[::2]     , dialogue[1::2] )
            ]     , []     , )
        if not (dialogue[-1][0]):
          raise ValueError(F"""Last message must be from user, got {dialogue[-1]['role']}""" )
        dialog_tokens += [self.bos_token_id] + self.encode(
            F"""{B_INST} {(dialogue[-1][1]).strip()} {E_INST}"""     , add_special_tokens=SCREAMING_SNAKE_CASE )
        return dialog_tokens












'''simple docstring'''


import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import SwinaSRForImageSuperResolution, SwinaSRModel
    from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import SwinaSRImageProcessor


class 		UpperCamelCase__     :
      '''simple docstring'''






      def __init__(     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE=13     , SCREAMING_SNAKE_CASE=32     , SCREAMING_SNAKE_CASE=1     , SCREAMING_SNAKE_CASE=3     , SCREAMING_SNAKE_CASE=16     , SCREAMING_SNAKE_CASE=[1, 2, 1]     , SCREAMING_SNAKE_CASE=[2, 2, 4]     , SCREAMING_SNAKE_CASE=2     , SCREAMING_SNAKE_CASE=2.0     , SCREAMING_SNAKE_CASE=True     , SCREAMING_SNAKE_CASE=0.0     , SCREAMING_SNAKE_CASE=0.0     , SCREAMING_SNAKE_CASE=0.1     , SCREAMING_SNAKE_CASE="gelu"     , SCREAMING_SNAKE_CASE=False     , SCREAMING_SNAKE_CASE=True     , SCREAMING_SNAKE_CASE=0.0_2     , SCREAMING_SNAKE_CASE=1e-5     , SCREAMING_SNAKE_CASE=True     , SCREAMING_SNAKE_CASE=None     , SCREAMING_SNAKE_CASE=False     , SCREAMING_SNAKE_CASE=2     , )				->  Tuple:
        __lowerCAmelCase		:    Optional[int]			     =  parent
        __lowerCAmelCase		:    List[str]			     =  batch_size
        __lowerCAmelCase		:    int			     =  image_size
        __lowerCAmelCase		:    List[Any]			     =  patch_size
        __lowerCAmelCase		:    List[Any]			     =  num_channels
        __lowerCAmelCase		:    Any			     =  embed_dim
        __lowerCAmelCase		:    List[str]			     =  depths
        __lowerCAmelCase		:    List[str]			     =  num_heads
        __lowerCAmelCase		:    Any			     =  window_size
        __lowerCAmelCase		:    Any			     =  mlp_ratio
        __lowerCAmelCase		:    Tuple			     =  qkv_bias
        __lowerCAmelCase		:    Optional[Any]			     =  hidden_dropout_prob
        __lowerCAmelCase		:    str			     =  attention_probs_dropout_prob
        __lowerCAmelCase		:    Optional[Any]			     =  drop_path_rate
        __lowerCAmelCase		:    Dict			     =  hidden_act
        __lowerCAmelCase		:    Dict			     =  use_absolute_embeddings
        __lowerCAmelCase		:    List[str]			     =  patch_norm
        __lowerCAmelCase		:    Dict			     =  layer_norm_eps
        __lowerCAmelCase		:    str			     =  initializer_range
        __lowerCAmelCase		:    int			     =  is_training
        __lowerCAmelCase		:    Optional[int]			     =  scope
        __lowerCAmelCase		:    str			     =  use_labels
        __lowerCAmelCase		:    int			     =  upscale

        # here we set some attributes to make tests pass
        __lowerCAmelCase		:    Any			     =  len(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Optional[int]			     =  embed_dim
        __lowerCAmelCase		:    Union[str, Any]			     =  (image_size // patch_size) ** 2




      def 	snake_case  (     self )				->  Tuple:
        __lowerCAmelCase		:    Union[str, Any]			     =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

        __lowerCAmelCase		:    Union[str, Any]			     =  None
        if self.use_labels:
          __lowerCAmelCase		:    int			     =  ids_tensor([self.batch_size]     , self.type_sequence_label_size )

        __lowerCAmelCase		:    List[Any]			     =  self.get_config()

        return config, pixel_values, labels




      def 	snake_case  (     self )				->  Any:
        return SwinaSRConfig(
            image_size=self.image_size     , patch_size=self.patch_size     , num_channels=self.num_channels     , embed_dim=self.embed_dim     , depths=self.depths     , num_heads=self.num_heads     , window_size=self.window_size     , mlp_ratio=self.mlp_ratio     , qkv_bias=self.qkv_bias     , hidden_dropout_prob=self.hidden_dropout_prob     , attention_probs_dropout_prob=self.attention_probs_dropout_prob     , drop_path_rate=self.drop_path_rate     , hidden_act=self.hidden_act     , use_absolute_embeddings=self.use_absolute_embeddings     , path_norm=self.patch_norm     , layer_norm_eps=self.layer_norm_eps     , initializer_range=self.initializer_range     , upscale=self.upscale     , )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Optional[Any]:
        __lowerCAmelCase		:    Dict			     =  SwinaSRModel(config=SCREAMING_SNAKE_CASE )
        model.to(SCREAMING_SNAKE_CASE )
        model.eval()
        __lowerCAmelCase		:    Dict			     =  model(SCREAMING_SNAKE_CASE )

        self.parent.assertEqual(
            result.last_hidden_state.shape     , (self.batch_size, self.embed_dim, self.image_size, self.image_size) )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Dict:
        __lowerCAmelCase		:    Any			     =  SwinaSRForImageSuperResolution(SCREAMING_SNAKE_CASE )
        model.to(SCREAMING_SNAKE_CASE )
        model.eval()
        __lowerCAmelCase		:    Tuple			     =  model(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Dict			     =  self.image_size * self.upscale
        self.parent.assertEqual(
            result.reconstruction.shape     , (self.batch_size, self.num_channels, expected_image_size, expected_image_size) )







      def 	snake_case  (     self )				->  Any:
        __lowerCAmelCase		:    List[Any]			     =  self.prepare_config_and_inputs()
        __lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase		:    Union[str, Any]			     =  config_and_inputs
        __lowerCAmelCase		:    str			     =  {'pixel_values': pixel_values}
        return config, inputs_dict



@require_torch
class 		UpperCamelCase__     (       a	,	a	,	unittest.TestCase							):
      '''simple docstring'''






      _snake_case           =				(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
      _snake_case           =				{'''feature-extraction''': SwinaSRModel} if is_torch_available() else {}

      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False




      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase		:    Optional[Any]			     =  SwinaSRModelTester(self )
        __lowerCAmelCase		:    List[str]			     =  ConfigTester(self     , config_class=SCREAMING_SNAKE_CASE     , embed_dim=37 )




      def 	snake_case  (     self )				->  Optional[int]:
        self.config_tester.create_and_test_config_to_json_string()
        self.config_tester.create_and_test_config_to_json_file()
        self.config_tester.create_and_test_config_from_and_save_pretrained()
        self.config_tester.create_and_test_config_with_num_labels()
        self.config_tester.check_config_can_be_init_without_params()
        self.config_tester.check_config_arguments_init()




      def 	snake_case  (     self )				->  Tuple:
        __lowerCAmelCase		:    Optional[int]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[Any]:
        __lowerCAmelCase		:    Union[str, Any]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_super_resolution(*SCREAMING_SNAKE_CASE )




      @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.' )
      def 	snake_case  (     self )				->  Any:
        pass




      @unittest.skip(reason='Swin2SR does not use inputs_embeds' )
      def 	snake_case  (     self )				->  List[str]:
        pass




      @unittest.skip(reason='Swin2SR does not support training yet' )
      def 	snake_case  (     self )				->  int:
        pass




      @unittest.skip(reason='Swin2SR does not support training yet' )
      def 	snake_case  (     self )				->  List[str]:
        pass




      def 	snake_case  (     self )				->  int:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Any			     =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    List[str]			     =  model_class(SCREAMING_SNAKE_CASE )
          self.assertIsInstance(model.get_input_embeddings()     , (nn.Module) )
          __lowerCAmelCase		:    Union[str, Any]			     =  model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE     , nn.Linear ) )




      def 	snake_case  (     self )				->  int:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    str			     =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Optional[Any]			     =  model_class(SCREAMING_SNAKE_CASE )
          __lowerCAmelCase		:    List[str]			     =  inspect.signature(model.forward )
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          __lowerCAmelCase		:    Optional[int]			     =  [*signature.parameters.keys()]

          __lowerCAmelCase		:    Dict			     =  ['pixel_values']
          self.assertListEqual(arg_names[:1]     , SCREAMING_SNAKE_CASE )




      @slow
      def 	snake_case  (     self )				->  List[Any]:
        for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          __lowerCAmelCase		:    Any			     =  SwinaSRModel.from_pretrained(SCREAMING_SNAKE_CASE )
          self.assertIsNotNone(SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Union[str, Any]			     =  self.model_tester.prepare_config_and_inputs_for_common()

        __lowerCAmelCase		:    List[Any]			     =  _config_zero_init(SCREAMING_SNAKE_CASE )
        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Any			     =  model_class(config=SCREAMING_SNAKE_CASE )
          for name, param in model.named_parameters():
            if "logit_scale" in name:
              continue
            if param.requires_grad:
              self.assertIn(
                  ((param.data.mean() * 1e9).round() / 1e9).item()     , [0.0, 1.0]     , msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""     , )







      def 	snake_case  (     self )				->  Dict:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Dict			     =  self.model_tester.prepare_config_and_inputs_for_common()
        __lowerCAmelCase		:    Dict			     =  True

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Tuple			     =  True
          __lowerCAmelCase		:    int			     =  False
          __lowerCAmelCase		:    Dict			     =  True
          __lowerCAmelCase		:    Optional[int]			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    Any			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )
          __lowerCAmelCase		:    Dict			     =  outputs.attentions
          __lowerCAmelCase		:    Optional[Any]			     =  len(self.model_tester.depths )
          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          # check that output_attentions also work using config
          del inputs_dict["output_attentions"]
          __lowerCAmelCase		:    str			     =  True
          __lowerCAmelCase		:    Any			     =  config.window_size**2
          __lowerCAmelCase		:    int			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    Optional[int]			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )
          __lowerCAmelCase		:    Optional[Any]			     =  outputs.attentions
          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          self.assertListEqual(
              list(attentions[0].shape[-3:] )     , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     , )
          __lowerCAmelCase		:    Dict			     =  len(SCREAMING_SNAKE_CASE )

          # Check attention is always last and order is fine
          __lowerCAmelCase		:    Optional[int]			     =  True
          __lowerCAmelCase		:    List[Any]			     =  True
          __lowerCAmelCase		:    Union[str, Any]			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    List[str]			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )

          self.assertEqual(out_len + 1     , len(SCREAMING_SNAKE_CASE ) )

          __lowerCAmelCase		:    Optional[Any]			     =  outputs.attentions

          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          self.assertListEqual(
              list(self_attentions[0].shape[-3:] )     , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     , )



@require_vision
@require_torch
@slow
class 		UpperCamelCase__     (       unittest.TestCase							):
      '''simple docstring'''






      def 	snake_case  (     self )				->  str:
        __lowerCAmelCase		:    int			     =  SwinaSRImageProcessor()
        __lowerCAmelCase		:    Optional[Any]			     =  SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64' ).to(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    int			     =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
        __lowerCAmelCase		:    Union[str, Any]			     =  processor(images=SCREAMING_SNAKE_CASE     , return_tensors='pt' ).to(SCREAMING_SNAKE_CASE )

        # forward pass
        with torch.no_grad():
          __lowerCAmelCase		:    List[Any]			     =  model(**SCREAMING_SNAKE_CASE )

        # verify the logits
        __lowerCAmelCase		:    Dict			     =  torch.Size([1, 3, 9_76, 12_96] )
        self.assertEqual(outputs.reconstruction.shape     , SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Optional[int]			     =  torch.tensor(
            [[0.5_4_5_8, 0.5_5_4_6, 0.5_6_3_8], [0.5_5_2_6, 0.5_5_6_5, 0.5_6_5_1], [0.5_3_9_6, 0.5_4_2_6, 0.5_6_2_1]] ).to(SCREAMING_SNAKE_CASE )
        self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]     , SCREAMING_SNAKE_CASE     , atol=1e-4 ) )





