





"""simple docstring"""




import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, PLBartTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


a		:				str  			=    get_tests_dir('''fixtures/test_sentencepiece.model''')


if is_torch_available():
  from transformers.models.plbart.modeling_plbart import shift_tokens_right

a		:				List[Any]  			=    50003
a		:				Union[str, Any]  			=    50002


@require_sentencepiece
@require_tokenizers
class  __UpperCamelCase       (		a__	, unittest.TestCase		):
       lowerCamelCase     :      List[Any]         =PLBartTokenizer
       lowerCamelCase     :      List[Any]         =None
       lowerCamelCase     :      Union[str, Any]         =False






       def 					__a     (     self   )			->				Union[str, Any]:
        super().setUp()

        # We have a SentencePiece fixture for testing
        a   :	List[str]			=       PLBartTokenizer(lowerCAmelCase__   ,      language_codes="base"   ,      keep_accents=lowerCAmelCase__   )
        tokenizer.save_pretrained(self.tmpdirname   )






       def 					__a     (     self   )			->				Dict:
        a   :	Optional[int]			=       PLBartTokenizer(lowerCAmelCase__   ,      language_codes="base"   ,      keep_accents=lowerCAmelCase__   )

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

        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(lowerCAmelCase__   )   ,      [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]   ,      )

        a   :	List[Any]			=       tokenizer.tokenize("I was born in 92000, and this is falsé."   )
        self.assertListEqual(
            lowerCAmelCase__   ,      [
                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   :	Union[str, Any]			=       tokenizer.convert_tokens_to_ids(lowerCAmelCase__   )
        self.assertListEqual(
            lowerCAmelCase__   ,      [
                value + tokenizer.fairseq_offset
                for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
            ]   ,      )

        a   :	Tuple			=       tokenizer.convert_ids_to_tokens(lowerCAmelCase__   )
        self.assertListEqual(
            lowerCAmelCase__   ,      [
                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>",
                ".",
            ]   ,      )

        a   :	Optional[int]			=       tokenizer.vocab_size
        a   :	Any			=       [tokenizer.convert_ids_to_tokens(lowerCAmelCase__   ) for x in range(end - 4   ,      lowerCAmelCase__   )]

        self.assertListEqual(lowerCAmelCase__   ,      ["__java__", "__python__", "__en_XX__", "<mask>"]   )

        a   :	Any			=       "java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
        a   :	Optional[int]			=       tokenizer(lowerCAmelCase__   ).input_ids
        self.assertEqual(
            tokenizer.decode(lowerCAmelCase__   ,      skip_special_tokens=lowerCAmelCase__   ,      clean_up_tokenization_spaces=lowerCAmelCase__   )   ,      lowerCAmelCase__   ,      )






       def 					__a     (     self   )			->				Tuple:
        a   :	Any			=       PLBartTokenizer(lowerCAmelCase__   ,      language_codes="multi"   ,      keep_accents=lowerCAmelCase__   )

        a   :	Dict			=       tokenizer.tokenize("This is a test"   )
        self.assertListEqual(lowerCAmelCase__   ,      ["▁This", "▁is", "▁a", "▁t", "est"]   )

        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(lowerCAmelCase__   )   ,      [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]   ,      )

        a   :	int			=       tokenizer.tokenize("I was born in 92000, and this is falsé."   )
        self.assertListEqual(
            lowerCAmelCase__   ,      [
                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   :	str			=       tokenizer.convert_tokens_to_ids(lowerCAmelCase__   )
        self.assertListEqual(
            lowerCAmelCase__   ,      [
                value + tokenizer.fairseq_offset
                for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
            ]   ,      )

        a   :	Union[str, Any]			=       tokenizer.convert_ids_to_tokens(lowerCAmelCase__   )
        self.assertListEqual(
            lowerCAmelCase__   ,      [
                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>",
                ".",
            ]   ,      )
        a   :	Dict			=       tokenizer.vocab_size
        a   :	List[Any]			=       [tokenizer.convert_ids_to_tokens(lowerCAmelCase__   ) for x in range(end - 7   ,      lowerCAmelCase__   )]

        self.assertListEqual(
            lowerCAmelCase__   ,      ["__java__", "__python__", "__en_XX__", "__javascript__", "__php__", "__ruby__", "__go__"]   )
        a   :	List[str]			=       "java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
        a   :	int			=       tokenizer(lowerCAmelCase__   ).input_ids
        self.assertEqual(
            tokenizer.decode(lowerCAmelCase__   ,      skip_special_tokens=lowerCAmelCase__   ,      clean_up_tokenization_spaces=lowerCAmelCase__   )   ,      lowerCAmelCase__   ,      )


@require_torch
@require_sentencepiece
@require_tokenizers
class  __UpperCamelCase       (		unittest.TestCase		):
       lowerCamelCase     :      int         ="""uclanlp/plbart-python-en_XX"""
       lowerCamelCase     :      Tuple         =[
           """def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])""",
           """def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])""",
       ]
       lowerCamelCase     :      List[Any]         =[
           """Returns the maximum value of a b c.""",
           """Sums the values of a b c.""",
       ]
       lowerCamelCase     :      List[Any]         =[
           134,
           5452,
           3_3460,
           3_3441,
           3_3463,
           3_3465,
           3_3463,
           3_3449,
           988,
           20,
           3_3456,
           19,
           3_3456,
           771,
           39,
           4258,
           889,
           3318,
           3_3441,
           3_3463,
           3_3465,
           3_3463,
           3_3449,
           2471,
           2,
           PYTHON_CODE,
       ]






       @classmethod
       def 					__a     (     cls   )			->				List[Any]:
        a   :	PLBartTokenizer			=       PLBartTokenizer.from_pretrained(
            cls.checkpoint_name   ,      language_codes="base"   ,      src_lang="python"   ,      tgt_lang="en_XX"   )
        a   :	Optional[Any]			=       1
        return cls






       def 					__a     (     self   )			->				List[str]:
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__java__"]   ,      5_0001   )
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__python__"]   ,      5_0002   )
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__en_XX__"]   ,      5_0003   )






       def 					__a     (     self   )			->				int:
        a   :	List[str]			=       self.tokenizer.batch_encode_plus(self.src_text   ).input_ids[0]
        self.assertListEqual(self.expected_src_tokens   ,      lowerCAmelCase__   )






       def 					__a     (     self   )			->				int:
        self.assertIn(lowerCAmelCase__   ,      self.tokenizer.all_special_ids   )
        a   :	List[str]			=       [EN_CODE, 9037, 3_3442, 57, 752, 153, 14, 56, 18, 9, 2]
        a   :	List[Any]			=       self.tokenizer.decode(lowerCAmelCase__   ,      skip_special_tokens=lowerCAmelCase__   )
        a   :	Dict			=       self.tokenizer.decode(generated_ids[1:]   ,      skip_special_tokens=lowerCAmelCase__   )
        self.assertEqual(lowerCAmelCase__   ,      lowerCAmelCase__   )
        self.assertNotIn(self.tokenizer.eos_token   ,      lowerCAmelCase__   )






       def 					__a     (     self   )			->				List[Any]:
        a   :	Union[str, Any]			=       ["def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])" * 20]
        self.assertIsInstance(src_text[0]   ,      lowerCAmelCase__   )
        a   :	Optional[Any]			=       10
        a   :	Tuple			=       self.tokenizer(lowerCAmelCase__   ,      max_length=lowerCAmelCase__   ,      truncation=lowerCAmelCase__   ).input_ids[0]
        self.assertEqual(ids[-2]   ,      2   )
        self.assertEqual(ids[-1]   ,      lowerCAmelCase__   )
        self.assertEqual(len(lowerCAmelCase__   )   ,      lowerCAmelCase__   )






       def 					__a     (     self   )			->				Tuple:
        self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "__java__"]   )   ,      [5_0004, 5_0001]   )






       def 					__a     (     self   )			->				Tuple:
        a   :	str			=       tempfile.mkdtemp()
        a   :	int			=       self.tokenizer.fairseq_tokens_to_ids
        self.tokenizer.save_pretrained(lowerCAmelCase__   )
        a   :	List[str]			=       PLBartTokenizer.from_pretrained(lowerCAmelCase__   )
        self.assertDictEqual(new_tok.fairseq_tokens_to_ids   ,      lowerCAmelCase__   )






       @require_torch
       def 					__a     (     self   )			->				Optional[int]:
        a   :	List[Any]			=       self.tokenizer(self.src_text   ,      text_target=self.tgt_text   ,      padding=lowerCAmelCase__   ,      return_tensors="pt"   )
        a   :	str			=       shift_tokens_right(batch["labels"]   ,      self.tokenizer.pad_token_id   )

        # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
        self.assertEqual(batch.input_ids[1][-2:].tolist()   ,      [2, PYTHON_CODE]   )
        self.assertEqual(batch.decoder_input_ids[1][0]   ,      lowerCAmelCase__   )
        self.assertEqual(batch.decoder_input_ids[1][-1]   ,      2   )
        self.assertEqual(batch.labels[1][-2:].tolist()   ,      [2, EN_CODE]   )






       @require_torch
       def 					__a     (     self   )			->				Dict:
        a   :	Optional[int]			=       self.tokenizer(
            self.src_text   ,      text_target=self.tgt_text   ,      padding=lowerCAmelCase__   ,      truncation=lowerCAmelCase__   ,      max_length=len(self.expected_src_tokens   )   ,      return_tensors="pt"   ,      )
        a   :	Optional[int]			=       shift_tokens_right(batch["labels"]   ,      self.tokenizer.pad_token_id   )

        self.assertIsInstance(lowerCAmelCase__   ,      lowerCAmelCase__   )

        self.assertEqual((2, 26)   ,      batch.input_ids.shape   )
        self.assertEqual((2, 26)   ,      batch.attention_mask.shape   )
        a   :	Union[str, Any]			=       batch.input_ids.tolist()[0]
        self.assertListEqual(self.expected_src_tokens   ,      lowerCAmelCase__   )
        self.assertEqual(2   ,      batch.decoder_input_ids[0, -1]   )  # EOS
        # Test that special tokens are reset
        self.assertEqual(self.tokenizer.prefix_tokens   ,      []   )
        self.assertEqual(self.tokenizer.suffix_tokens   ,      [self.tokenizer.eos_token_id, PYTHON_CODE]   )






       def 					__a     (     self   )			->				Any:
        a   :	Optional[Any]			=       self.tokenizer(self.src_text   ,      padding=lowerCAmelCase__   ,      truncation=lowerCAmelCase__   ,      max_length=3   ,      return_tensors="pt"   )
        a   :	List[str]			=       self.tokenizer(
            text_target=self.tgt_text   ,      padding=lowerCAmelCase__   ,      truncation=lowerCAmelCase__   ,      max_length=10   ,      return_tensors="pt"   )
        a   :	List[Any]			=       targets["input_ids"]
        a   :	Tuple			=       shift_tokens_right(lowerCAmelCase__   ,      self.tokenizer.pad_token_id   )

        self.assertEqual(batch.input_ids.shape[1]   ,      3   )
        self.assertEqual(batch.decoder_input_ids.shape[1]   ,      10   )






       @require_torch
       def 					__a     (     self   )			->				List[Any]:
        a   :	List[Any]			=       self.tokenizer._build_translation_inputs(
            "A test"   ,      return_tensors="pt"   ,      src_lang="en_XX"   ,      tgt_lang="java"   )

        self.assertEqual(
            nested_simplify(lowerCAmelCase__   )   ,      {
                # A, test, EOS, en_XX
                "input_ids": [[150, 242, 2, 5_0003]],
                "attention_mask": [[1, 1, 1, 1]],
                # java
                "forced_bos_token_id": 5_0001,
            }   ,      )









"""simple docstring"""




a		:				str  			=    8.314_4598






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					float					, _lowercase		:					float      )				->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
		a		:				Any  			=    300
		a		:				Dict  			=    28
		a		:				Dict  			=    rms_speed_of_molecule(temperature, molar_mass)
		print(F'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')


