code: 
  '''simple docstring'''
  
  import inspect
  import json
  import os
  import tempfile
  import unittest
  
  from transformers.models.speech_to_text_a import SpeechaTextaTokenizer
  from transformers.models.speech_to_text_a.tokenization_speech_to_text_a import VOCAB_FILES_NAMES
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  class   a_  (_a							,			unittest.TestCase    ):
         __lowerCAmelCase    :				Dict    =      SpeechaTextaTokenizer
         __lowerCAmelCase    :				Tuple    =      False
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           super().setUp()
  
           _lowerCAmelCase       :  Tuple   				=					"""<s> <pad> </s> <unk> here@@ a couple of@@ words for the he@@ re@@ vocab""".split(""" """  )
           _lowerCAmelCase       :  Dict   				=					["""he re</w> 123""", """here a 1456"""]
           _lowerCAmelCase       :  Dict   				=					dict(zip(snake_case_   ,   range(len(snake_case_  )  )  )  )
  
           _lowerCAmelCase       :  Union[str, Any]   				=					{"""pad_token""": """<pad>""", """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>"""}
  
           _lowerCAmelCase       :  List[Any]   				=					tempfile.mkdtemp()
           _lowerCAmelCase       :  Dict   				=					os.path.join(self.tmpdirname   ,   VOCAB_FILES_NAMES["""vocab_file"""]  )
           _lowerCAmelCase       :  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(snake_case_  ) + """\n"""  )
  
           with open(self.merges_file   ,   """w"""  ) as fp:
             fp.write("""\n""".join(snake_case_  )  )
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Optional[Any]   				=					list(self.get_tokenizer().get_vocab().keys()  )
  
           self.assertEqual(vocab_keys[0]   ,   """<s>"""  )
           self.assertEqual(vocab_keys[1]   ,   """<pad>"""  )
           self.assertEqual(vocab_keys[-1]   ,   """vocab"""  )
           self.assertEqual(len(snake_case_  )   ,   1_4  )
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           self.assertEqual(self.get_tokenizer().vocab_size   ,   1_4  )
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Dict   				=					SpeechaTextaTokenizer.from_pretrained(self.tmpdirname  )
  
           # make sure @@ is correctly concatenated
           _lowerCAmelCase       :  Union[str, Any]   				=					[4, 6, 8, 7, 1_0]  # ["here@@", "couple", "words", "of@@", "the"]
           _lowerCAmelCase       :  Union[str, Any]   				=					tokenizer.decode(snake_case_  )
  
           self.assertTrue(output_string == """herecouple words ofthe"""  )
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  str   				=					SpeechaTextaTokenizer.from_pretrained(self.tmpdirname  )
  
           with tempfile.TemporaryDirectory() as tmp_dirname:
             tokenizer.save_pretrained(snake_case_  )
             os.remove(os.path.join(snake_case_   ,   """merges.txt"""  )  )
  
             # load tokenizer without merges file should not throw an error
             _lowerCAmelCase       :  str   				=					SpeechaTextaTokenizer.from_pretrained(snake_case_  )
  
           with tempfile.TemporaryDirectory() as tmp_dirname:
             # save tokenizer and load again
             tokenizer.save_pretrained(snake_case_  )
             _lowerCAmelCase       :  Optional[Any]   				=					SpeechaTextaTokenizer.from_pretrained(snake_case_  )
  
           self.assertIsNotNone(snake_case_  )
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           if not self.test_slow_tokenizer:
             return
  
           _lowerCAmelCase       :  Any   				=					inspect.signature(self.tokenizer_class.__init__  )
           _lowerCAmelCase       :  List[str]   				=					self.get_tokenizer()
  
           for parameter_name, parameter in signature.parameters.items():
             if parameter.default != inspect.Parameter.empty and parameter_name != "merges_file":
               self.assertIn(snake_case_   ,   tokenizer.init_kwargs  )
  
  
  
style_context: 
  '''simple docstring'''
  
  import random
  
  
  class   a_  :
  
  
  
  
         def __init__(     self   ,   snake_case_   ,   snake_case_  ):
           _lowerCAmelCase       :  List[str]   				=					x
           _lowerCAmelCase       :  List[str]   				=					y
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           return (self.x**2 + self.y**2) <= 1
  
  
  
  
  
  
  
         @classmethod
         def 							__UpperCamelCase       (     cls  ):
           return cls(x=random.random()   ,   y=random.random()  )
  
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int		)    ->						float:
    if number_of_simulations < 1:
      raise ValueError("""At least one simulation is necessary to estimate PI."""		)
  
    _lowerCAmelCase       :  Tuple   				=					0
    for _ in range(_lowerCamelCase		):
      _lowerCAmelCase       :  Union[str, Any]   				=					Point.random_unit_square()
  
      if random_point.is_in_unit_circle():
        number_in_unit_circle += 1
  
    return 4 * number_in_unit_circle / number_of_simulations
  
  
  if __name__ == "__main__":
       # import doctest
  
       # doctest.testmod()
       from math import pi
  
       UpperCamelCase_     			=       """Please enter the desired number of Monte Carlo simulations: """
       UpperCamelCase_     			=       estimate_pi(int(input(prompt).strip()))
       print(F'An estimate of PI is {my_pi} with an error of {abs(my_pi - pi)}')
  
  
  