

'''simple docstring'''
import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_snake_case      =    '▁'

_snake_case      =    get_tests_dir('fixtures/test_sentencepiece.model')


@require_sentencepiece
@require_tokenizers
class   a__    (				_snake_case    , unittest.TestCase    ):
   _SCREAMING_SNAKE_CASE       :	Dict      			=				BigBirdTokenizer
   _SCREAMING_SNAKE_CASE       :	Union[str, Any]      			=				BigBirdTokenizerFast
   _SCREAMING_SNAKE_CASE       :	Union[str, Any]      			=				True
   _SCREAMING_SNAKE_CASE       :	Dict      			=				True


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      super().setUp()

      _lowercase     : Tuple     	=  self.tokenizer_class(_UpperCamelCase     ,							keep_accents=_UpperCamelCase    )
      tokenizer.save_pretrained(self.tmpdirname    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : Any     	=  "<s>"
      _lowercase     : Dict     	=  1

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


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : List[str]     	=  list(self.get_tokenizer().get_vocab().keys()    )

      self.assertEqual(vocab_keys[0]     ,							"<unk>"    )
      self.assertEqual(vocab_keys[1]     ,							"<s>"    )
      self.assertEqual(vocab_keys[-1]     ,							"[MASK]"    )
      self.assertEqual(len(_UpperCamelCase    )     ,							1004    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      self.assertEqual(self.get_tokenizer().vocab_size     ,							1000    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      if not self.test_rust_tokenizer:
         return

      _lowercase     : Tuple     	=  self.get_tokenizer()
      _lowercase     : Optional[Any]     	=  self.get_rust_tokenizer()

      _lowercase     : int     	=  "I was born in 92000, and this is falsé."

      _lowercase     : List[str]     	=  tokenizer.tokenize(_UpperCamelCase    )
      _lowercase     : Optional[Any]     	=  rust_tokenizer.tokenize(_UpperCamelCase    )
      self.assertListEqual(_UpperCamelCase     ,							_UpperCamelCase    )

      _lowercase     : Dict     	=  tokenizer.encode(_UpperCamelCase     ,							add_special_tokens=_UpperCamelCase    )
      _lowercase     : str     	=  rust_tokenizer.encode(_UpperCamelCase     ,							add_special_tokens=_UpperCamelCase    )
      self.assertListEqual(_UpperCamelCase     ,							_UpperCamelCase    )

      _lowercase     : Optional[int]     	=  self.get_rust_tokenizer()
      _lowercase     : Optional[Any]     	=  tokenizer.encode(_UpperCamelCase    )
      _lowercase     : int     	=  rust_tokenizer.encode(_UpperCamelCase    )
      self.assertListEqual(_UpperCamelCase     ,							_UpperCamelCase    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : List[str]     	=  BigBirdTokenizer(_UpperCamelCase     ,							keep_accents=_UpperCamelCase    )

      _lowercase     : Optional[int]     	=  tokenizer.tokenize("This is a test"    )
      self.assertListEqual(_UpperCamelCase     ,							["▁This", "▁is", "▁a", "▁t", "est"]    )

      self.assertListEqual(
          tokenizer.convert_tokens_to_ids(_UpperCamelCase    )     ,							[285, 46, 10, 170, 382]     ,							)

      _lowercase     : List[Any]     	=  tokenizer.tokenize("I was born in 92000, and this is falsé."    )
      self.assertListEqual(
          _UpperCamelCase     ,							[
              SPIECE_UNDERLINE + "I",
              SPIECE_UNDERLINE + "was",
              SPIECE_UNDERLINE + "b",
              "or",
              "n",
              SPIECE_UNDERLINE + "in",
              SPIECE_UNDERLINE + "",
              "9",
              "2",
              "0",
              "0",
              "0",
              ",",
              SPIECE_UNDERLINE + "and",
              SPIECE_UNDERLINE + "this",
              SPIECE_UNDERLINE + "is",
              SPIECE_UNDERLINE + "f",
              "al",
              "s",
              "é",
              ".",
          ]     ,							)
      _lowercase     : Optional[int]     	=  tokenizer.convert_tokens_to_ids(_UpperCamelCase    )
      self.assertListEqual(
          _UpperCamelCase     ,							[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]     ,							)

      _lowercase     : int     	=  tokenizer.convert_ids_to_tokens(_UpperCamelCase    )
      self.assertListEqual(
          _UpperCamelCase     ,							[
              SPIECE_UNDERLINE + "I",
              SPIECE_UNDERLINE + "was",
              SPIECE_UNDERLINE + "b",
              "or",
              "n",
              SPIECE_UNDERLINE + "in",
              SPIECE_UNDERLINE + "",
              "<unk>",
              "2",
              "0",
              "0",
              "0",
              ",",
              SPIECE_UNDERLINE + "and",
              SPIECE_UNDERLINE + "this",
              SPIECE_UNDERLINE + "is",
              SPIECE_UNDERLINE + "f",
              "al",
              "s",
              "<unk>",
              ".",
          ]     ,							)


   @cached_property
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      return BigBirdTokenizer.from_pretrained("google/bigbird-roberta-base"    )


   @slow
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : int     	=  "Hello World!"
      _lowercase     : str     	=  [65, 18536, 2260, 101, 66]

      self.assertListEqual(_UpperCamelCase     ,							self.big_tokenizer.encode(_UpperCamelCase    )    )


   @slow
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : Union[str, Any]     	=  (
          "This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"
          " add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"
      )
      # fmt: off
      _lowercase     : Optional[Any]     	=  [65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 34324, 497, 391, 408, 11342, 1244, 385, 100, 938, 985, 456, 574, 362, 12597, 3200, 3129, 1172, 66]  # noqa: E231
      # fmt: on
      self.assertListEqual(_UpperCamelCase     ,							self.big_tokenizer.encode(_UpperCamelCase    )    )


   @require_torch
   @slow
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      import torch

      from transformers import BigBirdConfig, BigBirdModel

      # Build sequence
      _lowercase     : Union[str, Any]     	=  list(self.big_tokenizer.get_vocab().keys()    )[:10]
      _lowercase     : Optional[int]     	=  " ".join(_UpperCamelCase    )
      _lowercase     : Dict     	=  self.big_tokenizer.encode_plus(_UpperCamelCase     ,							return_tensors="pt"     ,							return_token_type_ids=_UpperCamelCase    )
      _lowercase     : Optional[int]     	=  self.big_tokenizer.batch_encode_plus(
          [sequence + " " + sequence]     ,							return_tensors="pt"     ,							return_token_type_ids=_UpperCamelCase    )

      _lowercase     : List[str]     	=  BigBirdConfig(attention_type="original_full"    )
      _lowercase     : str     	=  BigBirdModel(_UpperCamelCase    )

      assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

      with torch.no_grad():
         model(**_UpperCamelCase    )
         model(**_UpperCamelCase    )


   @slow
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : str     	=  BigBirdTokenizer.from_pretrained("google/bigbird-roberta-base"    )
      _lowercase     : Optional[Any]     	=  tokenizer.decode(tokenizer("Paris is the [MASK]."    ).input_ids    )

      self.assertTrue(decoded_text == "[CLS] Paris is the[MASK].[SEP]"    )






   @slow
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : Tuple     	=  {"input_ids": [[65, 39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114, 66], [65, 448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 66, 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], [65, 484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 66, 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, 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, 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, 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, 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], [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, 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]]}  # noqa: E501
      # fmt: on

      self.tokenizer_integration_test_util(
          expected_encoding=_UpperCamelCase     ,							model_name="google/bigbird-roberta-base"     ,							revision="215c99f1600e06f83acce68422f2035b2b5c3510"     ,							)













'''simple docstring'''

from pathlib import PurePosixPath
from typing import Optional

import fsspec
from fsspec import AbstractFileSystem
from huggingface_hub.hf_api import DatasetInfo

from ..utils.file_utils import get_authentication_headers_for_url
from ..utils.hub import hf_hub_url







class __a			( _snake_case      ):
   __UpperCamelCase :			Any						   =						''
   __UpperCamelCase :			int						   =						'hf-legacy'  # "hf://"" is reserved for hffs





   def __init__(       self					:      Any					,lowerCamelCase					:      Optional[DatasetInfo] = None					,lowerCamelCase					:      Optional[str] = None					,**lowerCamelCase					:      Dict					,):

      '''simple docstring'''

      super().__init__(self					,**lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							repo_info
      __SCREAMING_SNAKE_CASE   				=							token
      __SCREAMING_SNAKE_CASE   				=							None





   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      if self.dir_cache is None:
         __SCREAMING_SNAKE_CASE   				=							{}
         for hf_file in self.repo_info.siblings:
            # TODO(QL): add sizes
            __SCREAMING_SNAKE_CASE   				=							{
                """name""": hf_file.rfilename,
                """size""": None,
                """type""": """file""",
            }
            self.dir_cache.update(
                {
                    str(lowerCamelCase     ): {"""name""": str(lowerCamelCase     ), """size""": None, """type""": """directory"""}
                    for d in list(PurePosixPath(hf_file.rfilename     ).parents     )[:-1]
                }     )





   def   UpperCAmelCase__  (       self					:      List[Any]					,lowerCamelCase					:      str					,lowerCamelCase					:      str = "rb"					,**lowerCamelCase					:      Optional[Any]					,):

      '''simple docstring'''

      if not isinstance(self.repo_info					,lowerCamelCase     ):
         raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}"""     )
      __SCREAMING_SNAKE_CASE   				=							hf_hub_url(self.repo_info.id					,lowerCamelCase					,revision=self.repo_info.sha     )
      return fsspec.open(
          lowerCamelCase					,mode=lowerCamelCase					,headers=get_authentication_headers_for_url(lowerCamelCase					,use_auth_token=self.token     )					,client_kwargs={"""trust_env""": True}					,).open()





   def   UpperCAmelCase__  (       self					:      Tuple					,lowerCamelCase					:      Any					,**lowerCamelCase					:      Optional[Any]     ):

      '''simple docstring'''

      self._get_dirs()
      __SCREAMING_SNAKE_CASE   				=							self._strip_protocol(lowerCamelCase     )
      if path in self.dir_cache:
         return self.dir_cache[path]
      else:
         raise FileNotFoundError(lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      str					,lowerCamelCase					:      Any					,lowerCamelCase					:      str=False					,**lowerCamelCase					:      Any     ):

      '''simple docstring'''

      self._get_dirs()
      __SCREAMING_SNAKE_CASE   				=							PurePosixPath(path.strip("""/"""     )     )
      __SCREAMING_SNAKE_CASE   				=							{}
      for p, f in self.dir_cache.items():
         __SCREAMING_SNAKE_CASE   				=							PurePosixPath(p.strip("""/"""     )     )
         __SCREAMING_SNAKE_CASE   				=							p.parent
         if root == path:
            __SCREAMING_SNAKE_CASE   				=							f
      __SCREAMING_SNAKE_CASE   				=							list(paths.values()     )
      if detail:
         return out
      else:
         return sorted(f["""name"""] for f in out     )





