'''simple docstring'''

import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, ByTaTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
     SCREAMING_SNAKE_CASE__											=     'pt'
elif is_tf_available():
     SCREAMING_SNAKE_CASE__											=     'tf'
else:
     SCREAMING_SNAKE_CASE__											=     'jax'






class        a_		(    UpperCAmelCase__			, unittest.TestCase       ):
  lowercase  	=   ByTaTokenizer
  lowercase  	=   False

  def 						A__		(   self   )						->   int:



        """simple docstring"""






        super().setUp()
        UpperCamelCase       						=      ByTaTokenizer()
        tokenizer.save_pretrained(self.tmpdirname   )

  @cached_property
  def 						A__		(   self   )						->   Dict:



        """simple docstring"""






        return ByTaTokenizer.from_pretrained("""google/byt5-small"""   )

  def 						A__		(   self    ,	**_SCREAMING_SNAKE_CASE   )						->   ByTaTokenizer:



        """simple docstring"""






        return self.tokenizer_class.from_pretrained(self.tmpdirname    ,	**_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE=False    ,	_SCREAMING_SNAKE_CASE=20    ,	_SCREAMING_SNAKE_CASE=5   )						->   Tuple[str, list]:



        """simple docstring"""






        UpperCamelCase       						=      []
        for i in range(len(_SCREAMING_SNAKE_CASE   )   ):
              try:
                    UpperCamelCase       						=      tokenizer.decode([i]    ,	clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE   )
              except UnicodeDecodeError:
                    pass
              toks.append((i, tok)   )

        UpperCamelCase       						=      list(filter(lambda _SCREAMING_SNAKE_CASE   : re.match(R"""^[ a-zA-Z]+$"""    ,	t[1]   )    ,	_SCREAMING_SNAKE_CASE   )   )
        UpperCamelCase       						=      list(filter(lambda _SCREAMING_SNAKE_CASE   : [t[0]] == tokenizer.encode(t[1]    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )    ,	_SCREAMING_SNAKE_CASE   )   )
        if max_length is not None and len(_SCREAMING_SNAKE_CASE   ) > max_length:
              UpperCamelCase       						=      toks[:max_length]
        if min_length is not None and len(_SCREAMING_SNAKE_CASE   ) < min_length and len(_SCREAMING_SNAKE_CASE   ) > 0:
              while len(_SCREAMING_SNAKE_CASE   ) < min_length:
                    UpperCamelCase       						=      toks + toks
              # toks_str = [t[1] for t in toks]
        UpperCamelCase       						=      [t[0] for t in toks]

        # Ensure consistency
        UpperCamelCase       						=      tokenizer.decode(_SCREAMING_SNAKE_CASE    ,	clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE   )
        if " " not in output_txt and len(_SCREAMING_SNAKE_CASE   ) > 1:
              UpperCamelCase       						=      (
                  tokenizer.decode([toks_ids[0]]    ,	clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE   )
                  + """ """
                  + tokenizer.decode(toks_ids[1:]    ,	clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE   )
              )
        if with_prefix_space:
              UpperCamelCase       						=      """ """ + output_txt
        UpperCamelCase       						=      tokenizer.encode(_SCREAMING_SNAKE_CASE    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )
        return output_txt, output_ids

  def 						A__		(   self   )						->   Any:



        """simple docstring"""






        UpperCamelCase       						=      self.ta_base_tokenizer
        UpperCamelCase       						=      tokenizer(["""hi</s>""", """I went to the gym</s>""", """</s>"""]   )
        UpperCamelCase       						=      tokenizer(["""hi""", """I went to the gym""", """"""]   )
        self.assertListEqual(batch_with_eos_added["""input_ids"""]    ,	batch_without_eos_added["""input_ids"""]   )

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      self.ta_base_tokenizer
        UpperCamelCase       						=      """Unicode €."""
        UpperCamelCase       						=      tokenizer(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      [88, 113, 108, 102, 114, 103, 104, 35, 229, 133, 175, 49, 1]
        self.assertEqual(encoded["""input_ids"""]    ,	_SCREAMING_SNAKE_CASE   )

        # decoding
        UpperCamelCase       						=      tokenizer.decode(_SCREAMING_SNAKE_CASE   )
        self.assertEqual(_SCREAMING_SNAKE_CASE    ,	"""Unicode €.</s>"""   )

        UpperCamelCase       						=      tokenizer("""e è é ê ë"""   )
        UpperCamelCase       						=      [104, 35, 198, 171, 35, 198, 172, 35, 198, 173, 35, 198, 174, 1]
        self.assertEqual(encoded["""input_ids"""]    ,	_SCREAMING_SNAKE_CASE   )
        # decoding
        UpperCamelCase       						=      tokenizer.decode(_SCREAMING_SNAKE_CASE   )
        self.assertEqual(_SCREAMING_SNAKE_CASE    ,	"""e è é ê ë</s>"""   )

        # encode/decode, but with `encode` instead of `__call__`
        self.assertEqual(tokenizer.decode(tokenizer.encode("""e è é ê ë"""   )   )    ,	"""e è é ê ë</s>"""   )

  def 						A__		(   self   )						->   Optional[int]:



        """simple docstring"""






        UpperCamelCase       						=      self.ta_base_tokenizer
        UpperCamelCase       						=      ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
        # fmt: off
        UpperCamelCase       						=      [68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 1, 0]
        # fmt: on
        UpperCamelCase       						=      tokenizer(_SCREAMING_SNAKE_CASE    ,	padding=_SCREAMING_SNAKE_CASE    ,	return_tensors=_SCREAMING_SNAKE_CASE   )
        self.assertIsInstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

        if FRAMEWORK != "jax":
              UpperCamelCase       						=      list(batch.input_ids.numpy()[0]   )
        else:
              UpperCamelCase       						=      list(batch.input_ids.tolist()[0]   )

        self.assertListEqual(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

        self.assertEqual((2, 37)    ,	batch.input_ids.shape   )
        self.assertEqual((2, 37)    ,	batch.attention_mask.shape   )

  def 						A__		(   self   )						->   int:



        """simple docstring"""






        UpperCamelCase       						=      self.ta_base_tokenizer
        UpperCamelCase       						=      ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
        UpperCamelCase       						=      tokenizer(_SCREAMING_SNAKE_CASE    ,	padding=_SCREAMING_SNAKE_CASE    ,	return_tensors=_SCREAMING_SNAKE_CASE   )
        # check if input_ids are returned and no decoder_input_ids
        self.assertIn("""input_ids"""    ,	_SCREAMING_SNAKE_CASE   )
        self.assertIn("""attention_mask"""    ,	_SCREAMING_SNAKE_CASE   )
        self.assertNotIn("""decoder_input_ids"""    ,	_SCREAMING_SNAKE_CASE   )
        self.assertNotIn("""decoder_attention_mask"""    ,	_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self   )						->   str:



        """simple docstring"""






        UpperCamelCase       						=      self.ta_base_tokenizer
        UpperCamelCase       						=      [
            """Summary of the text.""",
            """Another summary.""",
        ]
        UpperCamelCase       						=      tokenizer(
            text_target=_SCREAMING_SNAKE_CASE    ,	max_length=32    ,	padding="""max_length"""    ,	truncation=_SCREAMING_SNAKE_CASE    ,	return_tensors=_SCREAMING_SNAKE_CASE   )
        self.assertEqual(32    ,	targets["""input_ids"""].shape[1]   )

  def 						A__		(   self   )						->   Dict:



        """simple docstring"""






        UpperCamelCase       						=      self.ta_base_tokenizer
        UpperCamelCase       						=      ["""A long paragraph for summarization. </s>"""]
        UpperCamelCase       						=      ["""Summary of the text. </s>"""]
        # fmt: off
        UpperCamelCase       						=      [68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 35, 1]
        UpperCamelCase       						=      [86, 120, 112, 112, 100, 117, 124, 35, 114, 105, 35, 119, 107, 104, 35, 119, 104, 123, 119, 49, 35, 1]
        # fmt: on

        UpperCamelCase       						=      tokenizer(_SCREAMING_SNAKE_CASE    ,	text_target=_SCREAMING_SNAKE_CASE   )

        self.assertEqual(_SCREAMING_SNAKE_CASE    ,	batch["""input_ids"""][0]   )
        self.assertEqual(_SCREAMING_SNAKE_CASE    ,	batch["""labels"""][0]   )

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      self.get_tokenizers()
        for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"   ):
                    self.assertNotEqual(tokenizer.model_max_length    ,	42   )

              # Now let's start the test
        UpperCamelCase       						=      self.get_tokenizers()
        for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"   ):
                    # Isolate this from the other tests because we save additional tokens/etc
                    UpperCamelCase       						=      tempfile.mkdtemp()

                    UpperCamelCase       						=      """ He is very happy, UNwant\u00E9d,running"""
                    UpperCamelCase       						=      tokenizer.encode(_SCREAMING_SNAKE_CASE    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )
                    tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE   )

                    UpperCamelCase       						=      tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE   )
                    UpperCamelCase       						=      after_tokenizer.encode(_SCREAMING_SNAKE_CASE    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )
                    self.assertListEqual(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

                    shutil.rmtree(_SCREAMING_SNAKE_CASE   )

        UpperCamelCase       						=      self.get_tokenizers(model_max_length=42   )
        for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"   ):
                    # Isolate this from the other tests because we save additional tokens/etc
                    UpperCamelCase       						=      tempfile.mkdtemp()

                    UpperCamelCase       						=      """ He is very happy, UNwant\u00E9d,running"""
                    tokenizer.add_tokens(["""bim""", """bambam"""]   )
                    UpperCamelCase       						=      tokenizer.additional_special_tokens
                    additional_special_tokens.append("""new_additional_special_token"""   )
                    tokenizer.add_special_tokens({"""additional_special_tokens""": additional_special_tokens}   )
                    UpperCamelCase       						=      tokenizer.encode(_SCREAMING_SNAKE_CASE    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )
                    tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE   )

                    UpperCamelCase       						=      tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE   )
                    UpperCamelCase       						=      after_tokenizer.encode(_SCREAMING_SNAKE_CASE    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )
                    self.assertListEqual(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
                    self.assertIn("""new_additional_special_token"""    ,	after_tokenizer.additional_special_tokens   )
                    self.assertEqual(after_tokenizer.model_max_length    ,	42   )

                    UpperCamelCase       						=      tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE    ,	model_max_length=43   )
                    self.assertEqual(tokenizer.model_max_length    ,	43   )

                    shutil.rmtree(_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      []
        if self.test_slow_tokenizer:
              tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())   )

        if self.test_rust_tokenizer:
              tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())   )

        for tokenizer_class, tokenizer_utils in tokenizer_list:
              with tempfile.TemporaryDirectory() as tmp_dir:
                    tokenizer_utils.save_pretrained(_SCREAMING_SNAKE_CASE   )

                    with open(os.path.join(_SCREAMING_SNAKE_CASE    ,	"""special_tokens_map.json"""   )    ,	encoding="""utf-8"""   ) as json_file:
                          UpperCamelCase       						=      json.load(_SCREAMING_SNAKE_CASE   )

                    with open(os.path.join(_SCREAMING_SNAKE_CASE    ,	"""tokenizer_config.json"""   )    ,	encoding="""utf-8"""   ) as json_file:
                          UpperCamelCase       						=      json.load(_SCREAMING_SNAKE_CASE   )

                    UpperCamelCase       						=      [F"<extra_id_{i}>" for i in range(125   )]

                    UpperCamelCase       						=      added_tokens_extra_ids + [
                        """an_additional_special_token"""
                    ]
                    UpperCamelCase       						=      added_tokens_extra_ids + [
                        """an_additional_special_token"""
                    ]

                    with open(os.path.join(_SCREAMING_SNAKE_CASE    ,	"""special_tokens_map.json"""   )    ,	"""w"""    ,	encoding="""utf-8"""   ) as outfile:
                          json.dump(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
                    with open(os.path.join(_SCREAMING_SNAKE_CASE    ,	"""tokenizer_config.json"""   )    ,	"""w"""    ,	encoding="""utf-8"""   ) as outfile:
                          json.dump(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

                    # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
                    # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
                    # "special_tokens_map.json" files
                    UpperCamelCase       						=      tokenizer_class.from_pretrained(
                        _SCREAMING_SNAKE_CASE    ,	)
                    self.assertIn(
                        """an_additional_special_token"""    ,	tokenizer_without_change_in_init.additional_special_tokens   )
                    # self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
                    self.assertEqual(
                        ["""an_additional_special_token"""]    ,	tokenizer_without_change_in_init.convert_ids_to_tokens(
                            tokenizer_without_change_in_init.convert_tokens_to_ids(["""an_additional_special_token"""]   )   )    ,	)

                    # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                    UpperCamelCase       						=      added_tokens_extra_ids + [AddedToken("""a_new_additional_special_token"""    ,	lstrip=_SCREAMING_SNAKE_CASE   )]
                    UpperCamelCase       						=      tokenizer_class.from_pretrained(
                        _SCREAMING_SNAKE_CASE    ,	additional_special_tokens=_SCREAMING_SNAKE_CASE    ,	)

                    self.assertIn("""a_new_additional_special_token"""    ,	tokenizer.additional_special_tokens   )
                    self.assertEqual(
                        ["""a_new_additional_special_token"""]    ,	tokenizer.convert_ids_to_tokens(
                            tokenizer.convert_tokens_to_ids(["""a_new_additional_special_token"""]   )   )    ,	)

  def 						A__		(   self   )						->   Optional[int]:



        """simple docstring"""






        UpperCamelCase       						=      []
        if self.test_slow_tokenizer:
              tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())   )

        if self.test_rust_tokenizer:
              tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())   )

        for tokenizer_class, tokenizer_utils in tokenizer_list:
              with tempfile.TemporaryDirectory() as tmp_dir:
                    tokenizer_utils.save_pretrained(_SCREAMING_SNAKE_CASE   )

                    UpperCamelCase       						=      tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE   )

                    self.assertTrue(tokenizer.decode([255]   ) == """"""   )

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



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   Tuple:



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   Dict:



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   Optional[Any]:



        """simple docstring"""






        UpperCamelCase       						=      self.get_tokenizers(fast=_SCREAMING_SNAKE_CASE    ,	do_lower_case=_SCREAMING_SNAKE_CASE   )
        for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"   ):
                    UpperCamelCase       						=      ["""t""", """h""", """i""", """s""", """ """, """i""", """s""", """ """, """a""", """ """, """t""", """e""", """x""", """t""", """</s>"""]
                    UpperCamelCase       						=      tokenizer.convert_tokens_to_string(_SCREAMING_SNAKE_CASE   )

                    self.assertIsInstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )


  def 						A__		(   self   )						->   Dict:



        """simple docstring"""






        UpperCamelCase       						=      self.get_tokenizers()
        for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"   ):
                    UpperCamelCase       						=      [
                        """bos_token""",
                        """eos_token""",
                        """unk_token""",
                        """sep_token""",
                        """pad_token""",
                        """cls_token""",
                        """mask_token""",
                    ]

                    UpperCamelCase       						=      0
                    UpperCamelCase       						=      tokenizer.convert_ids_to_tokens(
                        _SCREAMING_SNAKE_CASE    ,	skip_special_tokens=_SCREAMING_SNAKE_CASE   )

                    for attr in attributes_list:
                          setattr(_SCREAMING_SNAKE_CASE    ,	attr + """_id"""    ,	_SCREAMING_SNAKE_CASE   )
                          self.assertEqual(getattr(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )    ,	_SCREAMING_SNAKE_CASE   )
                          self.assertEqual(getattr(_SCREAMING_SNAKE_CASE    ,	attr + """_id"""   )    ,	_SCREAMING_SNAKE_CASE   )

                          setattr(_SCREAMING_SNAKE_CASE    ,	attr + """_id"""    ,	_SCREAMING_SNAKE_CASE   )
                          self.assertEqual(getattr(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )    ,	_SCREAMING_SNAKE_CASE   )
                          self.assertEqual(getattr(_SCREAMING_SNAKE_CASE    ,	attr + """_id"""   )    ,	_SCREAMING_SNAKE_CASE   )

                    setattr(_SCREAMING_SNAKE_CASE    ,	"""additional_special_tokens_ids"""    ,	[]   )
                    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE    ,	"""additional_special_tokens"""   )    ,	[]   )
                    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE    ,	"""additional_special_tokens_ids"""   )    ,	[]   )

                    setattr(_SCREAMING_SNAKE_CASE    ,	"""additional_special_tokens_ids"""    ,	[token_id_to_test_setters]   )
                    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE    ,	"""additional_special_tokens"""   )    ,	[token_to_test_setters]   )
                    self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE    ,	"""additional_special_tokens_ids"""   )    ,	[token_id_to_test_setters]   )








'''simple docstring'''

from math import factorial







def 					lowercase__				(   __UpperCamelCase = 20					)->				int:
      UpperCamelCase       						=      2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
      # 2, 3,...
      UpperCamelCase       						=      n // 2

      return int(factorial(__UpperCamelCase					) / (factorial(__UpperCamelCase					) * factorial(n - k					))					)


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          print(solution(2_0))
     else:
          try:
               SCREAMING_SNAKE_CASE__											=     int(sys.argv[1])
               print(solution(n))
          except ValueError:
               print('Invalid entry - please enter a number.')
