


'''simple docstring'''
import json
import os
import unittest

from transformers import AutoTokenizer, GPTaTokenizer, GPTaTokenizerFast
from transformers.models.gpta.tokenization_gpta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class 			lowerCamelCase_   (	__lowercase     ,       unittest.TestCase      ):
      lowerCAmelCase__		     =     GPTaTokenizer
      lowerCAmelCase__		     =     GPTaTokenizerFast
      lowerCAmelCase__		     =     True
      lowerCAmelCase__		     =     {"add_prefix_space": True}
      lowerCAmelCase__		     =     False






      def lowercase_							(					self				:    Dict ):


          '''simple docstring'''


          super().setUp()

          # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
          UpperCAmelCase__			:		str													=				[
              '''l''',
              '''o''',
              '''w''',
              '''e''',
              '''r''',
              '''s''',
              '''t''',
              '''i''',
              '''d''',
              '''n''',
              '''\u0120''',
              '''\u0120l''',
              '''\u0120n''',
              '''\u0120lo''',
              '''\u0120low''',
              '''er''',
              '''\u0120lowest''',
              '''\u0120newer''',
              '''\u0120wider''',
              '''<unk>''',
              '''<|endoftext|>''',
          ]
          UpperCAmelCase__			:		List[Any]													=				dict(zip(_a						,						range(len(_a ) ) ) )
          UpperCAmelCase__			:		Tuple													=				['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
          UpperCAmelCase__			:		List[str]													=				{'''unk_token''': '''<unk>'''}

          UpperCAmelCase__			:		List[str]													=				os.path.join(self.tmpdirname						,						VOCAB_FILES_NAMES['''vocab_file'''] )
          UpperCAmelCase__			:		Tuple													=				os.path.join(self.tmpdirname						,						VOCAB_FILES_NAMES['''merges_file'''] )
          with open(self.vocab_file						,						'''w'''						,						encoding='''utf-8''' ) as fp:
              fp.write(json.dumps(_a ) + '''\n''' )
          with open(self.merges_file						,						'''w'''						,						encoding='''utf-8''' ) as fp:
              fp.write('''\n'''.join(_a ) )






      def lowercase_							(					self				:    Any						,						**_A				:    str ):


          '''simple docstring'''


          kwargs.update(self.special_tokens_map )
          return GPTaTokenizer.from_pretrained(self.tmpdirname						,						**_a )






      def lowercase_							(					self				:    Optional[int]						,						**_A				:    Tuple ):


          '''simple docstring'''


          kwargs.update(self.special_tokens_map )
          return GPTaTokenizerFast.from_pretrained(self.tmpdirname						,						**_a )






      def lowercase_							(					self				:    Union[str, Any]						,						_A				:    Dict ):


          '''simple docstring'''


          UpperCAmelCase__			:		Tuple													=				'''lower newer'''
          UpperCAmelCase__			:		Tuple													=				'''lower newer'''
          return input_text, output_text






      def lowercase_							(					self				:    Optional[int] ):


          '''simple docstring'''


          UpperCAmelCase__			:		Any													=				GPTaTokenizer(self.vocab_file						,						self.merges_file						,						**self.special_tokens_map )
          UpperCAmelCase__			:		int													=				'''lower newer'''
          UpperCAmelCase__			:		int													=				['''\u0120low''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er''']
          UpperCAmelCase__			:		List[str]													=				tokenizer.tokenize(_a						,						add_prefix_space=_a )
          self.assertListEqual(_a						,						_a )

          UpperCAmelCase__			:		Optional[int]													=				tokens + [tokenizer.unk_token]
          UpperCAmelCase__			:		List[Any]													=				[14, 15, 10, 9, 3, 2, 15, 19]
          self.assertListEqual(tokenizer.convert_tokens_to_ids(_a )						,						_a )






      def lowercase_							(					self				:    Optional[Any] ):


          '''simple docstring'''


          if not self.test_rust_tokenizer:
              return

          UpperCAmelCase__			:		int													=				self.get_tokenizer()
          UpperCAmelCase__			:		Tuple													=				self.get_rust_tokenizer(add_prefix_space=_a )

          UpperCAmelCase__			:		Tuple													=				'''lower newer'''

          # Testing tokenization
          UpperCAmelCase__			:		List[str]													=				tokenizer.tokenize(_a						,						add_prefix_space=_a )
          UpperCAmelCase__			:		Optional[Any]													=				rust_tokenizer.tokenize(_a )
          self.assertListEqual(_a						,						_a )

          # Testing conversion to ids without special tokens
          UpperCAmelCase__			:		List[Any]													=				tokenizer.encode(_a						,						add_special_tokens=_a						,						add_prefix_space=_a )
          UpperCAmelCase__			:		List[Any]													=				rust_tokenizer.encode(_a						,						add_special_tokens=_a )
          self.assertListEqual(_a						,						_a )

          # Testing conversion to ids with special tokens
          UpperCAmelCase__			:		List[str]													=				self.get_rust_tokenizer(add_prefix_space=_a )
          UpperCAmelCase__			:		List[str]													=				tokenizer.encode(_a						,						add_prefix_space=_a )
          UpperCAmelCase__			:		Tuple													=				rust_tokenizer.encode(_a )
          self.assertListEqual(_a						,						_a )

          # Testing the unknown token
          UpperCAmelCase__			:		Optional[Any]													=				tokens + [rust_tokenizer.unk_token]
          UpperCAmelCase__			:		str													=				[14, 15, 10, 9, 3, 2, 15, 19]
          self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(_a )						,						_a )






      def lowercase_							(					self				:    List[Any]						,						*_A				:    List[Any]						,						**_A				:    Any ):


          '''simple docstring'''


          pass






      def lowercase_							(					self				:    Tuple						,						_A				:    Dict=15 ):


          '''simple docstring'''


          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ):
                  UpperCAmelCase__			:		Optional[int]													=				self.rust_tokenizer_class.from_pretrained(_a						,						**_a )

                  # Simple input
                  UpperCAmelCase__			:		List[str]													=				'''This is a simple input'''
                  UpperCAmelCase__			:		Optional[Any]													=				['''This is a simple input 1''', '''This is a simple input 2''']
                  UpperCAmelCase__			:		Tuple													=				('''This is a simple input''', '''This is a pair''')
                  UpperCAmelCase__			:		Optional[Any]													=				[
                      ('''This is a simple input 1''', '''This is a simple input 2'''),
                      ('''This is a simple pair 1''', '''This is a simple pair 2'''),
                  ]

                  # Simple input tests
                  self.assertRaises(_a						,						tokenizer_r.encode						,						_a						,						max_length=_a						,						padding='''max_length''' )

                  # Simple input
                  self.assertRaises(_a						,						tokenizer_r.encode_plus						,						_a						,						max_length=_a						,						padding='''max_length''' )

                  # Simple input
                  self.assertRaises(
                      _a						,						tokenizer_r.batch_encode_plus						,						_a						,						max_length=_a						,						padding='''max_length'''						,						)

                  # Pair input
                  self.assertRaises(_a						,						tokenizer_r.encode						,						_a						,						max_length=_a						,						padding='''max_length''' )

                  # Pair input
                  self.assertRaises(_a						,						tokenizer_r.encode_plus						,						_a						,						max_length=_a						,						padding='''max_length''' )

                  # Pair input
                  self.assertRaises(
                      _a						,						tokenizer_r.batch_encode_plus						,						_a						,						max_length=_a						,						padding='''max_length'''						,						)






      def lowercase_							(					self				:    List[str] ):


          '''simple docstring'''


          UpperCAmelCase__			:		int													=				GPTaTokenizer.from_pretrained(self.tmpdirname						,						pad_token='''<pad>''' )

          # Simple input
          UpperCAmelCase__			:		int													=				'''This is a simple input'''
          UpperCAmelCase__			:		int													=				['''This is a simple input looooooooong''', '''This is a simple input''']
          UpperCAmelCase__			:		Any													=				('''This is a simple input''', '''This is a pair''')
          UpperCAmelCase__			:		Dict													=				[
              ('''This is a simple input loooooong''', '''This is a simple input'''),
              ('''This is a simple pair loooooong''', '''This is a simple pair'''),
          ]

          UpperCAmelCase__			:		Optional[int]													=				tokenizer.pad_token_id

          UpperCAmelCase__			:		List[Any]													=				tokenizer(_a						,						padding='''max_length'''						,						max_length=30						,						return_tensors='''np''' )
          UpperCAmelCase__			:		Optional[int]													=				tokenizer(_a						,						padding=_a						,						truncate=_a						,						return_tensors='''np''' )
          UpperCAmelCase__			:		int													=				tokenizer(*_a						,						padding='''max_length'''						,						max_length=60						,						return_tensors='''np''' )
          UpperCAmelCase__			:		Union[str, Any]													=				tokenizer(_a						,						padding=_a						,						truncate=_a						,						return_tensors='''np''' )

          # s
          # test single string max_length padding
          self.assertEqual(out_s['''input_ids'''].shape[-1]						,						30 )
          self.assertTrue(pad_token_id in out_s['''input_ids'''] )
          self.assertTrue(0 in out_s['''attention_mask'''] )

          # s2
          # test automatic padding
          self.assertEqual(out_sa['''input_ids'''].shape[-1]						,						33 )
          # long slice doesn't have padding
          self.assertFalse(pad_token_id in out_sa['''input_ids'''][0] )
          self.assertFalse(0 in out_sa['''attention_mask'''][0] )
          # short slice does have padding
          self.assertTrue(pad_token_id in out_sa['''input_ids'''][1] )
          self.assertTrue(0 in out_sa['''attention_mask'''][1] )

          # p
          # test single pair max_length padding
          self.assertEqual(out_p['''input_ids'''].shape[-1]						,						60 )
          self.assertTrue(pad_token_id in out_p['''input_ids'''] )
          self.assertTrue(0 in out_p['''attention_mask'''] )

          # p2
          # test automatic padding pair
          self.assertEqual(out_pa['''input_ids'''].shape[-1]						,						52 )
          # long slice pair doesn't have padding
          self.assertFalse(pad_token_id in out_pa['''input_ids'''][0] )
          self.assertFalse(0 in out_pa['''attention_mask'''][0] )
          # short slice pair does have padding
          self.assertTrue(pad_token_id in out_pa['''input_ids'''][1] )
          self.assertTrue(0 in out_pa['''attention_mask'''][1] )






      def lowercase_							(					self				:    List[str] ):


          '''simple docstring'''


          UpperCAmelCase__			:		Union[str, Any]													=				'''$$$'''
          UpperCAmelCase__			:		List[Any]													=				GPTaTokenizer.from_pretrained(self.tmpdirname						,						bos_token=_a						,						add_bos_token=_a )

          UpperCAmelCase__			:		Any													=				'''This is a simple input'''
          UpperCAmelCase__			:		str													=				['''This is a simple input 1''', '''This is a simple input 2''']

          UpperCAmelCase__			:		Tuple													=				tokenizer.bos_token_id

          UpperCAmelCase__			:		Optional[Any]													=				tokenizer(_a )
          UpperCAmelCase__			:		str													=				tokenizer(_a )

          self.assertEqual(out_s.input_ids[0]						,						_a )
          self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids ) )

          UpperCAmelCase__			:		str													=				tokenizer.decode(out_s.input_ids )
          UpperCAmelCase__			:		Optional[Any]													=				tokenizer.batch_decode(out_sa.input_ids )

          self.assertEqual(decode_s.split()[0]						,						_a )
          self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa ) )






      def lowercase_							(					self				:    Union[str, Any] ):


          '''simple docstring'''


          pass






      def lowercase_							(					self				:    List[Any] ):


          '''simple docstring'''


          UpperCAmelCase__			:		Optional[int]													=				[self.get_tokenizer(do_lower_case=_a						,						add_bos_token=_a )]
          for tokenizer in tokenizers:
              with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
                  UpperCAmelCase__			:		Tuple													=				'''Encode this.'''
                  UpperCAmelCase__			:		Optional[Any]													=				'''This one too please.'''
                  UpperCAmelCase__			:		List[Any]													=				tokenizer.encode(_a						,						add_special_tokens=_a )
                  encoded_sequence += tokenizer.encode(_a						,						add_special_tokens=_a )
                  UpperCAmelCase__			:		List[str]													=				tokenizer.encode_plus(
                      _a						,						_a						,						add_special_tokens=_a						,						return_special_tokens_mask=_a						,						)
                  UpperCAmelCase__			:		int													=				encoded_sequence_dict['''input_ids''']
                  UpperCAmelCase__			:		int													=				encoded_sequence_dict['''special_tokens_mask''']
                  self.assertEqual(len(_a )						,						len(_a ) )

                  UpperCAmelCase__			:		List[Any]													=				[
                      (x if not special_tokens_mask[i] else None) for i, x in enumerate(_a )
                  ]
                  UpperCAmelCase__			:		str													=				[x for x in filtered_sequence if x is not None]
                  self.assertEqual(_a						,						_a )




@require_tokenizers
class 			lowerCamelCase_   (	unittest.TestCase      ):






      def lowercase_							(					self				:    Any ):


          '''simple docstring'''


          UpperCAmelCase__			:		Any													=				AutoTokenizer.from_pretrained('''facebook/opt-350m'''						,						from_slow=_a )
          UpperCAmelCase__			:		int													=				'''A photo of a cat'''

          UpperCAmelCase__			:		List[Any]													=				tokenizer.encode(
              _a						,						)
          self.assertEqual(_a						,						[2, 250, 1_345, 9, 10, 4_758] )
          tokenizer.save_pretrained('''test_opt''' )

          UpperCAmelCase__			:		Union[str, Any]													=				AutoTokenizer.from_pretrained('''./test_opt''' )
          UpperCAmelCase__			:		Any													=				tokenizer.encode(
              _a						,						)
          self.assertEqual(_a						,						[2, 250, 1_345, 9, 10, 4_758] )






      def lowercase_							(					self				:    List[Any] ):


          '''simple docstring'''


          UpperCAmelCase__			:		Union[str, Any]													=				AutoTokenizer.from_pretrained('''facebook/opt-350m'''						,						use_slow=_a )
          UpperCAmelCase__			:		Any													=				'''A photo of a cat'''

          UpperCAmelCase__			:		Optional[int]													=				tokenizer.encode(
              _a						,						)
          # Same as above
          self.assertEqual(_a						,						[2, 250, 1_345, 9, 10, 4_758] )






      @unittest.skip('''This test is failing because of a bug in the fast tokenizer''' )
      def lowercase_							(					self				:    Tuple ):


          '''simple docstring'''


          UpperCAmelCase__			:		Union[str, Any]													=				AutoTokenizer.from_pretrained('''facebook/opt-350m'''						,						from_slow=_a )

          UpperCAmelCase__			:		Optional[Any]													=				'''bos'''
          UpperCAmelCase__			:		Optional[Any]													=				tokenizer.get_vocab()['''bos''']

          UpperCAmelCase__			:		str													=				'''A photo of a cat'''
          UpperCAmelCase__			:		int													=				tokenizer.encode(
              _a						,						)
          # We changed the bos token
          self.assertEqual(_a						,						[31_957, 250, 1_345, 9, 10, 4_758] )
          tokenizer.save_pretrained('''./tok''' )
          UpperCAmelCase__			:		Dict													=				AutoTokenizer.from_pretrained('''./tok''' )
          self.assertTrue(tokenizer.is_fast )
          UpperCAmelCase__			:		Union[str, Any]													=				tokenizer.encode(
              _a						,						)
          self.assertEqual(_a						,						[31_957, 250, 1_345, 9, 10, 4_758] )



def    __UpperCAmelCase (	__a      :			float	)			->     float:

					"""simple docstring"""

					return 10 - x * x



def    __UpperCAmelCase (	__a      :			float		,__a      :			float	)			->     float:

					"""simple docstring"""

					if equation(__a	) * equation(__a	) >= 0:
										raise ValueError('''Wrong space!'''	)

					_a	:    Dict         =		a
					while (b - a) >= 0.01:
										# Find middle point
										_a	:    Any         =		(a + b) / 2
										# Check if middle point is root
										if equation(__a	) == 0.0:
															break
										# Decide the side to repeat the steps
										if equation(__a	) * equation(__a	) < 0:
															_a	:    str         =		c
										else:
															_a	:    Union[str, Any]         =		c
					return c


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			print(bisection(-2, 5))
			print(bisection(0, 6))



