




'''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        lowercase_      (						_a						,       unittest.TestCase							):
     A_											=			GPTaTokenizer
     A_											=			GPTaTokenizerFast
     A_											=			True
     A_											=			{"add_prefix_space": True}
     A_											=			False





     def 			_lowerCAmelCase      (     self     :					Tuple			):
           super().setUp()

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

           snake_case__       :   str	      =    os.path.join(self.tmpdirname     ,							VOCAB_FILES_NAMES['vocab_file']			)
           snake_case__       :   str	      =    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(_SCREAMING_SNAKE_CASE			) + '\n'			)
           with open(self.merges_file     ,							'w'     ,							encoding='utf-8'			) as fp:
                 fp.write('\n'.join(_SCREAMING_SNAKE_CASE			)			)





     def 			_lowerCAmelCase      (     self     :					List[str]     ,							**__lowerCamelCase     :					Tuple			):
           kwargs.update(self.special_tokens_map			)
           return GPTaTokenizer.from_pretrained(self.tmpdirname     ,							**_SCREAMING_SNAKE_CASE			)





     def 			_lowerCAmelCase      (     self     :					Tuple     ,							**__lowerCamelCase     :					Optional[Any]			):
           kwargs.update(self.special_tokens_map			)
           return GPTaTokenizerFast.from_pretrained(self.tmpdirname     ,							**_SCREAMING_SNAKE_CASE			)





     def 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					List[Any]			):
           snake_case__       :   Optional[int]	      =    '''lower newer'''
           snake_case__       :   List[str]	      =    '''lower newer'''
           return input_text, output_text





     def 			_lowerCAmelCase      (     self     :					int			):
           snake_case__       :   List[str]	      =    GPTaTokenizer(self.vocab_file     ,							self.merges_file     ,							**self.special_tokens_map			)
           snake_case__       :   int	      =    '''lower newer'''
           snake_case__       :   Tuple	      =    ['''\u0120low''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er''']
           snake_case__       :   Dict	      =    tokenizer.tokenize(_SCREAMING_SNAKE_CASE     ,							add_prefix_space=_SCREAMING_SNAKE_CASE			)
           self.assertListEqual(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE			)

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





     def 			_lowerCAmelCase      (     self     :					Tuple			):
           if not self.test_rust_tokenizer:
                 return

           snake_case__       :   Union[str, Any]	      =    self.get_tokenizer()
           snake_case__       :   int	      =    self.get_rust_tokenizer(add_prefix_space=_SCREAMING_SNAKE_CASE			)

           snake_case__       :   Dict	      =    '''lower newer'''

           # Testing tokenization
           snake_case__       :   Dict	      =    tokenizer.tokenize(_SCREAMING_SNAKE_CASE     ,							add_prefix_space=_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Optional[int]	      =    rust_tokenizer.tokenize(_SCREAMING_SNAKE_CASE			)
           self.assertListEqual(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE			)

           # Testing conversion to ids without special tokens
           snake_case__       :   Any	      =    tokenizer.encode(_SCREAMING_SNAKE_CASE     ,							add_special_tokens=_SCREAMING_SNAKE_CASE     ,							add_prefix_space=_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Tuple	      =    rust_tokenizer.encode(_SCREAMING_SNAKE_CASE     ,							add_special_tokens=_SCREAMING_SNAKE_CASE			)
           self.assertListEqual(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE			)

           # Testing conversion to ids with special tokens
           snake_case__       :   str	      =    self.get_rust_tokenizer(add_prefix_space=_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Any	      =    tokenizer.encode(_SCREAMING_SNAKE_CASE     ,							add_prefix_space=_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Tuple	      =    rust_tokenizer.encode(_SCREAMING_SNAKE_CASE			)
           self.assertListEqual(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE			)

           # Testing the unknown token
           snake_case__       :   Dict	      =    tokens + [rust_tokenizer.unk_token]
           snake_case__       :   List[Any]	      =    [14, 15, 10, 9, 3, 2, 15, 19]
           self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE			)     ,							_SCREAMING_SNAKE_CASE			)





     def 			_lowerCAmelCase      (     self     :					str     ,							*__lowerCamelCase     :					List[Any]     ,							**__lowerCamelCase     :					Optional[Any]			):
           # It's very difficult to mix/test pretokenization with byte-level
           # And get both GPT2 and Roberta to work at the same time (mostly an issue of adding a space before the string)
           pass





     def 			_lowerCAmelCase      (     self     :					Optional[Any]     ,							__lowerCamelCase     :					List[Any]=15			):
           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                 with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"			):
                       snake_case__       :   Union[str, Any]	      =    self.rust_tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE     ,							**_SCREAMING_SNAKE_CASE			)

                       # Simple input
                       snake_case__       :   str	      =    '''This is a simple input'''
                       snake_case__       :   str	      =    ['''This is a simple input 1''', '''This is a simple input 2''']
                       snake_case__       :   int	      =    ('''This is a simple input''', '''This is a pair''')
                       snake_case__       :   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(_SCREAMING_SNAKE_CASE     ,							tokenizer_r.encode     ,							_SCREAMING_SNAKE_CASE     ,							max_length=_SCREAMING_SNAKE_CASE     ,							padding='max_length'			)

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

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

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

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

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





     def 			_lowerCAmelCase      (     self     :					List[str]			):
           snake_case__       :   Tuple	      =    GPTaTokenizer.from_pretrained(self.tmpdirname     ,							pad_token='<pad>'			)

           # Simple input
           snake_case__       :   str	      =    '''This is a simple input'''
           snake_case__       :   Tuple	      =    ['''This is a simple input looooooooong''', '''This is a simple input''']
           snake_case__       :   Union[str, Any]	      =    ('''This is a simple input''', '''This is a pair''')
           snake_case__       :   Optional[Any]	      =    [
               ('''This is a simple input loooooong''', '''This is a simple input'''),
               ('''This is a simple pair loooooong''', '''This is a simple pair'''),
           ]

           snake_case__       :   Union[str, Any]	      =    tokenizer.pad_token_id

           snake_case__       :   Dict	      =    tokenizer(_SCREAMING_SNAKE_CASE     ,							padding='max_length'     ,							max_length=30     ,							return_tensors='np'			)
           snake_case__       :   int	      =    tokenizer(_SCREAMING_SNAKE_CASE     ,							padding=_SCREAMING_SNAKE_CASE     ,							truncate=_SCREAMING_SNAKE_CASE     ,							return_tensors='np'			)
           snake_case__       :   Tuple	      =    tokenizer(*_SCREAMING_SNAKE_CASE     ,							padding='max_length'     ,							max_length=60     ,							return_tensors='np'			)
           snake_case__       :   List[Any]	      =    tokenizer(_SCREAMING_SNAKE_CASE     ,							padding=_SCREAMING_SNAKE_CASE     ,							truncate=_SCREAMING_SNAKE_CASE     ,							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 			_lowerCAmelCase      (     self     :					Optional[Any]			):
           snake_case__       :   List[Any]	      =    '''$$$'''
           snake_case__       :   Any	      =    GPTaTokenizer.from_pretrained(self.tmpdirname     ,							bos_token=_SCREAMING_SNAKE_CASE     ,							add_bos_token=_SCREAMING_SNAKE_CASE			)

           snake_case__       :   Tuple	      =    '''This is a simple input'''
           snake_case__       :   Union[str, Any]	      =    ['''This is a simple input 1''', '''This is a simple input 2''']

           snake_case__       :   List[Any]	      =    tokenizer.bos_token_id

           snake_case__       :   List[str]	      =    tokenizer(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Optional[Any]	      =    tokenizer(_SCREAMING_SNAKE_CASE			)

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

           snake_case__       :   Tuple	      =    tokenizer.decode(out_s.input_ids			)
           snake_case__       :   Union[str, Any]	      =    tokenizer.batch_decode(out_sa.input_ids			)

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





     def 			_lowerCAmelCase      (     self     :					Optional[int]			):
           pass





     def 			_lowerCAmelCase      (     self     :					int			):
           # TODO: change to self.get_tokenizers() when the fast version is implemented
           snake_case__       :   Tuple	      =    [self.get_tokenizer(do_lower_case=_SCREAMING_SNAKE_CASE     ,							add_bos_token=_SCREAMING_SNAKE_CASE			)]
           for tokenizer in tokenizers:
                 with self.subTest(F"{tokenizer.__class__.__name__}"			):
                       snake_case__       :   List[Any]	      =    '''Encode this.'''
                       snake_case__       :   List[Any]	      =    '''This one too please.'''
                       snake_case__       :   Optional[int]	      =    tokenizer.encode(_SCREAMING_SNAKE_CASE     ,							add_special_tokens=_SCREAMING_SNAKE_CASE			)
                       encoded_sequence += tokenizer.encode(_SCREAMING_SNAKE_CASE     ,							add_special_tokens=_SCREAMING_SNAKE_CASE			)
                       snake_case__       :   Dict	      =    tokenizer.encode_plus(
                           _SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							add_special_tokens=_SCREAMING_SNAKE_CASE     ,							return_special_tokens_mask=_SCREAMING_SNAKE_CASE     ,							)
                       snake_case__       :   int	      =    encoded_sequence_dict['''input_ids''']
                       snake_case__       :   Union[str, Any]	      =    encoded_sequence_dict['''special_tokens_mask''']
                       self.assertEqual(len(_SCREAMING_SNAKE_CASE			)     ,							len(_SCREAMING_SNAKE_CASE			)			)

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






@require_tokenizers
class        lowercase_      (						unittest.TestCase							):





     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           # More context:
           # https://huggingface.co/wjmcat/opt-350m-paddle/discussions/1
           # https://huggingface.slack.com/archives/C01N44FJDHT/p1653511495183519
           # https://github.com/huggingface/transformers/pull/17088#discussion_r871246439

           snake_case__       :   Any	      =    AutoTokenizer.from_pretrained('facebook/opt-350m'     ,							from_slow=_SCREAMING_SNAKE_CASE			)
           snake_case__       :   List[str]	      =    '''A photo of a cat'''

           snake_case__       :   Any	      =    tokenizer.encode(
               _SCREAMING_SNAKE_CASE     ,							)
           self.assertEqual(_SCREAMING_SNAKE_CASE     ,							[2, 250, 1345, 9, 10, 4758]			)
           tokenizer.save_pretrained('test_opt'			)

           snake_case__       :   Dict	      =    AutoTokenizer.from_pretrained('./test_opt'			)
           snake_case__       :   Optional[Any]	      =    tokenizer.encode(
               _SCREAMING_SNAKE_CASE     ,							)
           self.assertEqual(_SCREAMING_SNAKE_CASE     ,							[2, 250, 1345, 9, 10, 4758]			)





     def 			_lowerCAmelCase      (     self     :					str			):
           snake_case__       :   Tuple	      =    AutoTokenizer.from_pretrained('facebook/opt-350m'     ,							use_slow=_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Dict	      =    '''A photo of a cat'''

           snake_case__       :   int	      =    tokenizer.encode(
               _SCREAMING_SNAKE_CASE     ,							)
           # Same as above
           self.assertEqual(_SCREAMING_SNAKE_CASE     ,							[2, 250, 1345, 9, 10, 4758]			)





     @unittest.skip('This test is failing because of a bug in the fast tokenizer'			)
     def 			_lowerCAmelCase      (     self     :					int			):
           snake_case__       :   Union[str, Any]	      =    AutoTokenizer.from_pretrained('facebook/opt-350m'     ,							from_slow=_SCREAMING_SNAKE_CASE			)

           snake_case__       :   Any	      =    '''bos'''
           snake_case__       :   Dict	      =    tokenizer.get_vocab()['''bos''']

           snake_case__       :   Optional[int]	      =    '''A photo of a cat'''
           snake_case__       :   Any	      =    tokenizer.encode(
               _SCREAMING_SNAKE_CASE     ,							)
           # We changed the bos token
           self.assertEqual(_SCREAMING_SNAKE_CASE     ,							[31957, 250, 1345, 9, 10, 4758]			)
           tokenizer.save_pretrained('./tok'			)
           snake_case__       :   Optional[Any]	      =    AutoTokenizer.from_pretrained('./tok'			)
           self.assertTrue(tokenizer.is_fast			)
           snake_case__       :   Tuple	      =    tokenizer.encode(
               _SCREAMING_SNAKE_CASE     ,							)
           self.assertEqual(_SCREAMING_SNAKE_CASE     ,							[31957, 250, 1345, 9, 10, 4758]			)






from decimal import Decimal, getcontext
from math import ceil, factorial







def lowerCamelCase__  (     _lowercase ):

     '''simple docstring'''


     if not isinstance(_lowercase					,		_lowercase ):
          raise TypeError('''Undefined for non-integers''' )
     elif precision < 1:
          raise ValueError('''Undefined for non-natural numbers''' )

     UpperCAmelCase_     :				Tuple  =     precision
     UpperCAmelCase_     :				Optional[Any]  =     ceil(precision / 14 )
     UpperCAmelCase_     :				int  =     426880 * Decimal(10005 ).sqrt()
     UpperCAmelCase_     :				Tuple  =     1
     UpperCAmelCase_     :				List[Any]  =     13591409
     UpperCAmelCase_     :				Optional[Any]  =     Decimal(_lowercase )
     for k in range(1					,		_lowercase ):
          UpperCAmelCase_     :				List[str]  =     factorial(6 * k ) // (factorial(3 * k ) * factorial(_lowercase ) ** 3)
          linear_term += 545140134
          exponential_term *= -262537412640768000
          partial_sum += Decimal(multinomial_term * linear_term ) / exponential_term
     return str(constant_term / partial_sum )[:-1]


if __name__ == "__main__":
     __a							     =					50
     print(F"""The first {n} digits of pi is: {pi(n)}""")