


'''simple docstring'''







import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XGLMTokenizer, XGLMTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


A__:       Optional[Any]          =			get_tests_dir('''fixtures/test_sentencepiece.model''')







@require_sentencepiece
@require_tokenizers
class A__			(		__snake_case					,	unittest.TestCase ):
      __UpperCamelCase			:    Union[str, Any]      			=				XGLMTokenizer
      __UpperCamelCase			:    List[str]      			=				XGLMTokenizerFast
      __UpperCamelCase			:    Dict      			=				True
      __UpperCamelCase			:    int      			=				True






      def __UpperCAmelCase			(					self     :Dict      )			->   Dict:




             '''simple docstring'''
             super().setUp()

             # We have a SentencePiece fixture for testing
             _a       :					Union[str, Any]	   =XGLMTokenizer(_SCREAMING_SNAKE_CASE	,		keep_accents=_SCREAMING_SNAKE_CASE      )
             tokenizer.save_pretrained(self.tmpdirname      )






      def __UpperCAmelCase			(					self     :str      )			->   Optional[Any]:




             '''simple docstring'''
             _a       :					Dict	   ="""<pad>"""
             _a       :					Union[str, Any]	   =1

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






      def __UpperCAmelCase			(					self     :int      )			->   List[Any]:




             '''simple docstring'''
             _a       :					Any	   =list(self.get_tokenizer().get_vocab().keys()      )

             self.assertEqual(vocab_keys[0]	,		"""<s>"""      )
             self.assertEqual(vocab_keys[1]	,		"""<pad>"""      )
             self.assertEqual(len(_SCREAMING_SNAKE_CASE      )	,		1_0_0_8      )






      def __UpperCAmelCase			(					self     :Dict      )			->   Optional[int]:




             '''simple docstring'''
             self.assertEqual(self.get_tokenizer().vocab_size	,		1_0_0_8      )






      def __UpperCAmelCase			(					self     :str      )			->   Any:




             '''simple docstring'''
             _a       :					Dict	   =XGLMTokenizer(_SCREAMING_SNAKE_CASE	,		keep_accents=_SCREAMING_SNAKE_CASE      )

             _a       :					Optional[Any]	   =tokenizer.tokenize("""This is a test"""      )
             self.assertListEqual(_SCREAMING_SNAKE_CASE	,		["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]      )

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE      )	,		[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]	,		)

             _a       :					Tuple	   =tokenizer.tokenize("""I was born in 92000, and this is falsé."""      )
             self.assertListEqual(
                 _SCREAMING_SNAKE_CASE	,		[
                     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""",
                     """é""",
                     """.""",
                 ]	,		)
             _a       :					Dict	   =tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE      )
             self.assertListEqual(
                 _SCREAMING_SNAKE_CASE	,		[
                     value + tokenizer.fairseq_offset
                     for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
                 ]	,		)

             _a       :					Any	   =tokenizer.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE      )
             self.assertListEqual(
                 _SCREAMING_SNAKE_CASE	,		[
                     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 __UpperCAmelCase			(					self     :Tuple      )			->   int:




             '''simple docstring'''
             return XGLMTokenizer.from_pretrained("""facebook/xglm-564M"""      )






      def __UpperCAmelCase			(					self     :Optional[int]      )			->   Union[str, Any]:




             '''simple docstring'''




             with tempfile.NamedTemporaryFile() as f:
                    shutil.copyfile(_SCREAMING_SNAKE_CASE	,		f.name      )
                    _a       :					Any	   =XGLMTokenizer(f.name	,		keep_accents=_SCREAMING_SNAKE_CASE      )
                    _a       :					Tuple	   =pickle.dumps(_SCREAMING_SNAKE_CASE      )
             pickle.loads(_SCREAMING_SNAKE_CASE      )






      def __UpperCAmelCase			(					self     :List[Any]      )			->   List[str]:




             '''simple docstring'''




             if not self.test_rust_tokenizer:
                    return

             _a       :					str	   =self.get_tokenizer()
             _a       :					Optional[Any]	   =self.get_rust_tokenizer()

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

             _a       :					Any	   =tokenizer.tokenize(_SCREAMING_SNAKE_CASE      )
             _a       :					Optional[Any]	   =rust_tokenizer.tokenize(_SCREAMING_SNAKE_CASE      )
             self.assertListEqual(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE      )

             _a       :					Tuple	   =tokenizer.encode(_SCREAMING_SNAKE_CASE	,		add_special_tokens=_SCREAMING_SNAKE_CASE      )
             _a       :					Tuple	   =rust_tokenizer.encode(_SCREAMING_SNAKE_CASE	,		add_special_tokens=_SCREAMING_SNAKE_CASE      )
             self.assertListEqual(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE      )

             _a       :					Union[str, Any]	   =self.get_rust_tokenizer()
             _a       :					Union[str, Any]	   =tokenizer.encode(_SCREAMING_SNAKE_CASE      )
             _a       :					List[str]	   =rust_tokenizer.encode(_SCREAMING_SNAKE_CASE      )
             self.assertListEqual(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE      )






      @slow
      def __UpperCAmelCase			(					self     :Optional[Any]      )			->   int:




             '''simple docstring'''
             _a       :					Optional[int]	   ="""Hello World!"""
             _a       :					List[str]	   =[2, 3_1_2_2_7, 4_4_4_7, 3_5]

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






      @slow
      def __UpperCAmelCase			(					self     :str      )			->   str:




             '''simple docstring'''
             _a       :					Dict	   =(
                 """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
             _a       :					Optional[Any]	   =[2, 1_0_1_8, 6_7, 1_1, 1_9_8_8, 2_6_1_7, 5_6_3_1, 2_7_8, 1_1, 3_4_0_7, 4_8, 7_1_6_3_0, 2_8_0_8_5, 4, 3_2_3_4, 1_5_7, 1_3, 6, 5, 6, 4, 3_5_2_6, 7_6_8, 1_5, 6_5_9, 5_7, 2_9_8, 3_9_8_3, 8_6_4, 1_2_9, 2_1, 6, 5, 1_3_6_7_5, 3_7_7, 6_5_2, 7_5_8_0, 1_0_3_4_1, 1_5_5, 2_8_1_7, 4_2_2, 1_6_6_6, 7, 1_6_7_4, 5_3, 1_1_3, 2_0_2_2_7_7, 1_7_8_9_2, 3_3, 6_0, 8_7, 4, 3_2_3_4, 1_5_7, 6_1, 2_6_6_7, 5_2_3_7_6, 1_9, 8_8, 2_3, 7_3_5]
             # fmt: on

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






      @slow
      def __UpperCAmelCase			(					self     :Any      )			->   Tuple:




             '''simple docstring'''
             _a       :					List[Any]	   ={
                 """input_ids""": [[2, 1_0_8_8_2_5, 1_1_6_3, 1_5, 8_8_0_1_0, 4_7_3, 1_5_8_9_8, 1_5_7, 1_3_6_7_2, 1_8_5_7, 3_1_2, 8, 2_3_8_0_2_1, 1_1_6_3, 5_3, 1_3_6_7_2, 1_8_5_7, 3_1_2, 8, 5_3_2_8_3, 1_8_2_3_9_6, 8, 1_8_5_6_6, 1_6, 3_6_7_3_3, 4_1_0_1, 8, 2_3_0, 2_4_4_0_1_7, 1_2_2_5_5_3, 7, 1_5, 1_3_2_5_9_7, 4, 2_9_3, 1_2_5_1_1, 7_6_1_0, 4, 3_4_1_4, 1_3_2_5_9_7, 9, 4, 3_2_3_6_1, 3_6_2, 4, 7_3_4, 2_8_5_1_2, 3_2_5_6_9, 1_8, 4, 3_2_3_6_1, 2_6_0_9_6, 1_4_9_8_2, 7_3, 1_8_7_1_5, 2_1_4_3_3, 2_3_5_2_6_1, 1_5, 4_9_2, 1_2_4_2_7, 1_6, 5_3, 1_8_7_1_5, 2_1_4_3_3, 6_5_4_5_4, 1_5, 2_3_6_5_9, 5_6_3, 1_6, 2_7_8, 5_9_7, 2_8_4_3, 5_9_5, 7_9_3_1, 1_8_2_3_9_6, 6_4_1_8_6, 2_2, 8_8_6, 5_9_5, 1_3_2_9_8_1, 5_3, 2_5_5_4_0, 3_4_4_9, 4_3_9_8_2, 3_9_9_0_1, 5_9_5_1, 8_7_8, 3_3_0, 4, 2_7_6_9_4, 8_0_2_6_9, 3_1_2, 5_3, 6_5_1_7, 1_1_7_8_0, 6_1_1, 2_0_4_0_8, 5], [2, 6, 1_3_2_5_9_7, 6_7, 4_2_8_9_7, 3_3, 5_9_2, 8, 1_6_3_7_2_9, 2_5_5_4_0, 3_6_1, 1_3_6_9_9_7, 1_0_9_5_1_4, 1_7_3_2_3_0, 7, 5_0_1, 6_0, 1_0_2_9_1_3, 1_9_6, 5_6_3_1, 2_3_5, 6_3_2_4_3, 4_7_3, 6, 2_3_1_7_5_7, 7_4, 5_2_7_7, 7_9_0_5, 5_3, 3_0_9_5, 3_7_3_1_7, 2_2, 4_5_4, 1_8_3_8_7_4, 5], [2, 2_6_8, 3_1_2_9_8, 4_6_5_3_0, 6, 1_3_2_9_3_5, 4_3_8_3_1, 7, 5_9_7, 3_2, 2_4, 3_6_8_8, 9_8_6_5, 5]],
                 """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, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
             }  # noqa: E501
             # fmt: on

             self.tokenizer_integration_test_util(
                 expected_encoding=_SCREAMING_SNAKE_CASE	,		model_name="""facebook/xglm-564M"""	,		padding=_SCREAMING_SNAKE_CASE	,		)










__magic_name__   :  str        =							8.314_4598
def 		lowercase__  (				_UpperCamelCase       ,							_UpperCamelCase) ->			float:
      """simple docstring"""

      if temperature < 0:
            raise Exception('Temperature cannot be less than 0 K')
      if molar_mass <= 0:
            raise Exception('Molar mass cannot be less than or equal to 0 kg/mol')
      else:
            return (3 * UNIVERSAL_GAS_CONSTANT * temperature / molar_mass) ** 0.5


if __name__ == "__main__":
       import doctest

       # run doctest
       doctest.testmod()

       # example
       __magic_name__   :  List[Any]        =							300
       __magic_name__   :  Union[str, Any]        =							28
       __magic_name__   :  str        =							rms_speed_of_molecule(temperature, molar_mass)
       print(F'Vrms of Nitrogen gas at 300 K is {vrms} m/s')



