



import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


a_    :  Optional[Any]						  =		get_tests_dir('fixtures/test_sentencepiece_with_bytefallback.model')





@require_sentencepiece
@require_tokenizers
class  lowerCamelCase__	(    UpperCAmelCase_							,     unittest.TestCase):
     """simple docstring"""



     _A      =      GPTSwaTokenizer
     _A      =      False
     _A      =      True
     _A      =      False







     def     _a   (self     ):






           '''simple docstring'''



           super().setUp()

           # We have a SentencePiece fixture for testing
           lowerCamelCase             =		GPTSwaTokenizer(lowerCamelCase_					,      eos_token="<unk>"					,      bos_token="<unk>"					,      pad_token="<unk>"     )

           tokenizer.save_pretrained(self.tmpdirname     )







     def     _a   (self					,      __a     ):






           '''simple docstring'''



           lowerCamelCase             =		"This is a test"
           lowerCamelCase             =		"This is a test"
           return input_text, output_text







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		"<s>"
           lowerCamelCase             =		1

           self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase_     )					,      lowerCamelCase_     )
           self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase_     )					,      lowerCamelCase_     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		list(self.get_tokenizer().get_vocab().keys()     )

           self.assertEqual(vocab_keys[0]					,      "<unk>"     )
           self.assertEqual(vocab_keys[1]					,      "<s>"     )
           self.assertEqual(vocab_keys[-1]					,      "j"     )
           self.assertEqual(len(lowerCamelCase_     )					,      20_00     )







     def     _a   (self     ):






           '''simple docstring'''



           self.assertEqual(self.get_tokenizer().vocab_size					,      20_00     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		GPTSwaTokenizer(lowerCamelCase_     )

           lowerCamelCase             =		tokenizer.tokenize("This is a test"     )
           self.assertListEqual(lowerCamelCase_					,      ["▁This", "▁is", "▁a", "▁t", "est"]     )

           self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_     )					,      [4_65, 2_87, 2_65, 6_31, 8_42]     )

           lowerCamelCase             =		tokenizer.tokenize("I was born in 92000, and this is falsé."     )
           # fmt: off
           self.assertListEqual(
               lowerCamelCase_					,      ["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."]					,      )
           # fmt: on

           lowerCamelCase             =		tokenizer.convert_tokens_to_ids(lowerCamelCase_     )
           self.assertListEqual(
               lowerCamelCase_					,      [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60]					,      )

           lowerCamelCase             =		tokenizer.convert_ids_to_tokens(lowerCamelCase_     )
           # fmt: off
           self.assertListEqual(
               lowerCamelCase_					,      ["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."]     )
           # fmt: on







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		GPTSwaTokenizer(lowerCamelCase_     )
           lowerCamelCase             =		["This is a test", "I was born in 92000, and this is falsé."]
           lowerCamelCase             =		[
               [4_65, 2_87, 2_65, 6_31, 8_42],
               [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60],
           ]

           # Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
           for text, expected_ids in zip(lowerCamelCase_					,      lowerCamelCase_     ):
                 self.assertListEqual(tokenizer.encode_fast(lowerCamelCase_     )					,      lowerCamelCase_     )

           # Test that decode_fast returns the input text
           for text, token_ids in zip(lowerCamelCase_					,      lowerCamelCase_     ):
                 self.assertEqual(tokenizer.decode_fast(lowerCamelCase_     )					,      lowerCamelCase_     )







     @slow
     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		[
               "<|python|>def fibonacci(n)\n    if n < 0:\n        print('Incorrect input')",
               "Hey there, how are you doing this fine day?",
               "This is a text with a trailing spaces followed by a dot     .",
               "Häj sväjs lillebrör! =)",
               "Det är inget fel på Mr. Cool",
           ]

           # fmt: off
           lowerCamelCase             =		{"input_ids": [[6_34_23, 5, 68_11, 1_49_54, 2_82, 8_16, 38_21, 6_34_66, 6_34_25, 6_34_62, 18, 6_39_78, 6_78, 3_01, 13_20, 6_34_23, 6_34_55, 6_34_58, 18, 6_39_82, 42_46, 39_40, 19_01, 4_77_89, 55_47, 1_89_94], [1_96_30, 11_00, 6_34_46, 13_42, 6_33, 5_44, 44_88, 5_93, 51_02, 24_16, 6_34_95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [16_52, 4_28, 2_68, 19_36, 5_15, 2_68, 5_85_93, 2_24_13, 91_06, 5_46, 2_68, 3_32_13, 6_39_79, 6_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_51_30, 6_34_50, 9_24, 6_34_49, 22_49, 40_62, 15_58, 3_18, 6_35_04, 2_14_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_09, 3_77, 28_27, 25_59, 3_32, 65_75, 6_34_43, 2_68_01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "token_type_ids": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
           # fmt: on
           self.tokenizer_integration_test_util(
               expected_encoding=lowerCamelCase_					,      model_name="AI-Sweden/gpt-sw3-126m"					,      sequences=lowerCamelCase_					,      )


"""simple docstring"""


from typing import Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
  from PIL import Image

  from ..image_utils import load_image

if is_torch_available():
  from ..models.auto.modeling_auto import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING

UpperCAmelCase													=logging.get_logger(__name__)





@add_end_docstrings(SCREAMING_SNAKE_CASE    )
class lowerCamelCase__   (				SCREAMING_SNAKE_CASE    ):



    '''simple docstring'''




    def __init__( self ,*lowerCamelCase_ ,**lowerCamelCase_    )    ->      str:
          super().__init__(*lowerCamelCase_ ,**lowerCamelCase_    )
          self.check_model_type(lowerCamelCase_    )




    def UpperCamelCase__		( self ,lowerCamelCase_=None ,lowerCamelCase_=None ,lowerCamelCase_=None ,**lowerCamelCase_    )    ->      List[Any]:
          A  ,			A				  =		{}, {}
          if padding is not None:
                A				  =		padding
          if truncation is not None:
                A				  =		truncation
          if top_k is not None:
                A				  =		top_k
          return preprocess_params, {}, postprocess_params




    def __call__( self ,lowerCamelCase_ ,lowerCamelCase_ = None ,**lowerCamelCase_    )    ->      Dict:
          if isinstance(lowerCamelCase_ ,(Image.Image, str)    ) and isinstance(lowerCamelCase_ ,lowerCamelCase_    ):
                A				  =		{"""image""": image, """question""": question}
          else:
                A				  =		image
          A				  =		super().__call__(lowerCamelCase_ ,**lowerCamelCase_    )
          return results




    def UpperCamelCase__		( self ,lowerCamelCase_ ,lowerCamelCase_=False ,lowerCamelCase_=False    )    ->      List[Any]:
          A				  =		load_image(inputs["""image"""]    )
          A				  =		self.tokenizer(
              inputs["""question"""] ,return_tensors=self.framework ,padding=lowerCamelCase_ ,truncation=lowerCamelCase_    )
          A				  =		self.image_processor(images=lowerCamelCase_ ,return_tensors=self.framework    )
          model_inputs.update(lowerCamelCase_    )
          return model_inputs




    def UpperCamelCase__		( self ,lowerCamelCase_    )    ->      Union[str, Any]:
          A				  =		self.model(**lowerCamelCase_    )
          return model_outputs




    def UpperCamelCase__		( self ,lowerCamelCase_ ,lowerCamelCase_=5    )    ->      int:
          if top_k > self.model.config.num_labels:
                A				  =		self.model.config.num_labels

          if self.framework == "pt":
                A				  =		model_outputs.logits.sigmoid()[0]
                A  ,			A				  =		probs.topk(lowerCamelCase_    )
          else:
                raise ValueError(f'Unsupported framework: {self.framework}'    )

          A				  =		scores.tolist()
          A				  =		ids.tolist()
          return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase_ ,lowerCamelCase_    )]




