


'''simple docstring'''






import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
__A					:  Any											=      sys.version_info >= (3, 10)







def 				UpperCamelCase_			(    A__					:   Union[str, Any]=None							,    A__					:   Tuple=None					):
  '''simple docstring'''





  return field(default_factory=lambda: default							,    metadata=A__					)






@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					42
    lowercase    =					42
    lowercase    =					42
    lowercase    =					42







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					42
    lowercase    =					field(default='toto'	,metadata={'help': 'help message'})







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					False
    lowercase    =					True
    lowercase    =					None







class    __snake_case       (   _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase    =					'titi'
    lowercase    =					'toto'







class    __snake_case       (   _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase    =					'titi'
    lowercase    =					'toto'
    lowercase    =					42







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					"toto"

    def __lowercase   (   self    :  List[Any]		)   ->  List[Any]:
      lowerCAmelCase_			:      Optional[Any]			=   BasicEnum(self.foo		)







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					"toto"

    def __lowercase   (   self    :  List[str]		)   ->  Optional[int]:
      lowerCAmelCase_			:      Optional[int]			=   MixedTypeEnum(self.foo		)







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					None
    lowercase    =					field(default=_SCREAMING_SNAKE_CASE	,metadata={'help': 'help message'})
    lowercase    =					None
    lowercase    =					list_field(default=[])
    lowercase    =					list_field(default=[])







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					list_field(default=[])
    lowercase    =					list_field(default=[1, 2, 3])
    lowercase    =					list_field(default=['Hallo', 'Bonjour', 'Hello'])
    lowercase    =					list_field(default=[0.1, 0.2, 0.3])







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					field()
    lowercase    =					field()
    lowercase    =					field()

    def __lowercase   (   self    :  int		)   ->  Optional[Any]:
      lowerCAmelCase_			:      Tuple			=   BasicEnum(self.required_enum		)







@dataclass
class    __snake_case       :







    """simple docstring"""



    lowercase    =					42
    lowercase    =					field()
    lowercase    =					None
    lowercase    =					field(default='toto'	,metadata={'help': 'help message'})
    lowercase    =					list_field(default=['Hallo', 'Bonjour', 'Hello'])


if is_python_no_less_than_3_10:






  @dataclass
  class    __snake_case       :







      """simple docstring"""



      lowercase    =					False
      lowercase    =					True
      lowercase    =					None







  @dataclass
  class    __snake_case       :







      """simple docstring"""



      lowercase    =					None
      lowercase    =					field(default=_SCREAMING_SNAKE_CASE	,metadata={'help': 'help message'})
      lowercase    =					None
      lowercase    =					list_field(default=[])
      lowercase    =					list_field(default=[])






class    __snake_case       (   unittest.TestCase):







    """simple docstring"""



    def __lowercase   (   self    :  str    ,						lowerCamelCase    :  argparse.ArgumentParser    ,						lowerCamelCase    :  argparse.ArgumentParser		)   ->  List[str]:
      self.assertEqual(len(a._actions		)    ,						len(b._actions		)		)
      for x, y in zip(a._actions    ,						b._actions		):
        lowerCAmelCase_			:      List[str]			=   {k: v for k, v in vars(lowerCamelCase		).items() if k != """container"""}
        lowerCAmelCase_			:      Optional[int]			=   {k: v for k, v in vars(lowerCamelCase		).items() if k != """container"""}

        # Choices with mixed type have custom function as "type"
        # So we need to compare results directly for equality
        if xx.get("""choices"""    ,						lowerCamelCase		) and yy.get("""choices"""    ,						lowerCamelCase		):
          for expected_choice in yy["choices"] + xx["choices"]:
            self.assertEqual(xx["""type"""](lowerCamelCase		)    ,						yy["""type"""](lowerCamelCase		)		)
          del xx["type"], yy["type"]

        self.assertEqual(lowerCamelCase    ,						lowerCamelCase		)

    def __lowercase   (   self    :  Any		)   ->  Optional[int]:
      lowerCAmelCase_			:      Tuple			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      Optional[Any]			=   argparse.ArgumentParser()
      expected.add_argument("""--foo"""    ,						type=lowerCamelCase    ,						required=lowerCamelCase		)
      expected.add_argument("""--bar"""    ,						type=lowerCamelCase    ,						required=lowerCamelCase		)
      expected.add_argument("""--baz"""    ,						type=lowerCamelCase    ,						required=lowerCamelCase		)
      expected.add_argument("""--flag"""    ,						type=lowerCamelCase    ,						default=lowerCamelCase    ,						const=lowerCamelCase    ,						nargs="""?"""		)
      self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

      lowerCAmelCase_			:      Optional[int]			=   ["""--foo""", """1""", """--baz""", """quux""", """--bar""", """0.5"""]
      ((lowerCAmelCase_),							)			:      List[Any]			=   parser.parse_args_into_dataclasses(lowerCamelCase    ,						look_for_args_file=lowerCamelCase		)
      self.assertFalse(example.flag		)

    def __lowercase   (   self    :  Optional[Any]		)   ->  int:
      lowerCAmelCase_			:      Any			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      int			=   argparse.ArgumentParser()
      expected.add_argument("""--foo"""    ,						default=42    ,						type=lowerCamelCase		)
      expected.add_argument("""--baz"""    ,						default="""toto"""    ,						type=lowerCamelCase    ,						help="""help message"""		)
      self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

    def __lowercase   (   self    :  List[Any]		)   ->  Dict:
      lowerCAmelCase_			:      Dict			=   argparse.ArgumentParser()
      expected.add_argument("""--foo"""    ,						type=lowerCamelCase    ,						default=lowerCamelCase    ,						const=lowerCamelCase    ,						nargs="""?"""		)
      expected.add_argument("""--baz"""    ,						type=lowerCamelCase    ,						default=lowerCamelCase    ,						const=lowerCamelCase    ,						nargs="""?"""		)
      # A boolean no_* argument always has to come after its "default: True" regular counter-part
      # and its default must be set to False
      expected.add_argument("""--no_baz"""    ,						action="""store_false"""    ,						default=lowerCamelCase    ,						dest="""baz"""		)
      expected.add_argument("""--opt"""    ,						type=lowerCamelCase    ,						default=lowerCamelCase		)

      lowerCAmelCase_			:      List[Any]			=   [WithDefaultBoolExample]
      if is_python_no_less_than_3_10:
        dataclass_types.append(lowerCamelCase		)

      for dataclass_type in dataclass_types:
        lowerCAmelCase_			:      Any			=   HfArgumentParser(lowerCamelCase		)
        self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

        lowerCAmelCase_			:      Dict			=   parser.parse_args([]		)
        self.assertEqual(lowerCamelCase    ,						Namespace(foo=lowerCamelCase    ,						baz=lowerCamelCase    ,						opt=lowerCamelCase		)		)

        lowerCAmelCase_			:      Dict			=   parser.parse_args(["""--foo""", """--no_baz"""]		)
        self.assertEqual(lowerCamelCase    ,						Namespace(foo=lowerCamelCase    ,						baz=lowerCamelCase    ,						opt=lowerCamelCase		)		)

        lowerCAmelCase_			:      Optional[Any]			=   parser.parse_args(["""--foo""", """--baz"""]		)
        self.assertEqual(lowerCamelCase    ,						Namespace(foo=lowerCamelCase    ,						baz=lowerCamelCase    ,						opt=lowerCamelCase		)		)

        lowerCAmelCase_			:      str			=   parser.parse_args(["""--foo""", """True""", """--baz""", """True""", """--opt""", """True"""]		)
        self.assertEqual(lowerCamelCase    ,						Namespace(foo=lowerCamelCase    ,						baz=lowerCamelCase    ,						opt=lowerCamelCase		)		)

        lowerCAmelCase_			:      List[str]			=   parser.parse_args(["""--foo""", """False""", """--baz""", """False""", """--opt""", """False"""]		)
        self.assertEqual(lowerCamelCase    ,						Namespace(foo=lowerCamelCase    ,						baz=lowerCamelCase    ,						opt=lowerCamelCase		)		)

    def __lowercase   (   self    :  int		)   ->  Union[str, Any]:
      lowerCAmelCase_			:      Any			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      int			=   argparse.ArgumentParser()
      expected.add_argument(
          """--foo"""    ,						default="""toto"""    ,						choices=["""titi""", """toto""", 42]    ,						type=make_choice_type_function(["""titi""", """toto""", 42]		)    ,						)
      self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

      lowerCAmelCase_			:      Dict			=   parser.parse_args([]		)
      self.assertEqual(args.foo    ,						"""toto"""		)
      lowerCAmelCase_			:      int			=   parser.parse_args_into_dataclasses([]		)[0]
      self.assertEqual(enum_ex.foo    ,						MixedTypeEnum.toto		)

      lowerCAmelCase_			:      Optional[Any]			=   parser.parse_args(["""--foo""", """titi"""]		)
      self.assertEqual(args.foo    ,						"""titi"""		)
      lowerCAmelCase_			:      List[Any]			=   parser.parse_args_into_dataclasses(["""--foo""", """titi"""]		)[0]
      self.assertEqual(enum_ex.foo    ,						MixedTypeEnum.titi		)

      lowerCAmelCase_			:      Any			=   parser.parse_args(["""--foo""", """42"""]		)
      self.assertEqual(args.foo    ,						42		)
      lowerCAmelCase_			:      List[Any]			=   parser.parse_args_into_dataclasses(["""--foo""", """42"""]		)[0]
      self.assertEqual(enum_ex.foo    ,						MixedTypeEnum.fourtytwo		)

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






      @dataclass
      class    __snake_case       :







          """simple docstring"""



          lowercase    =					"toto"







      lowerCAmelCase_			:      Union[str, Any]			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      List[str]			=   argparse.ArgumentParser()
      expected.add_argument(
          """--foo"""    ,						default="""toto"""    ,						choices=("""titi""", """toto""", 42)    ,						type=make_choice_type_function(["""titi""", """toto""", 42]		)    ,						)
      self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

      lowerCAmelCase_			:      Tuple			=   parser.parse_args([]		)
      self.assertEqual(args.foo    ,						"""toto"""		)

      lowerCAmelCase_			:      Optional[Any]			=   parser.parse_args(["""--foo""", """titi"""]		)
      self.assertEqual(args.foo    ,						"""titi"""		)

      lowerCAmelCase_			:      Union[str, Any]			=   parser.parse_args(["""--foo""", """42"""]		)
      self.assertEqual(args.foo    ,						42		)

    def __lowercase   (   self    :  Any		)   ->  Optional[Any]:
      lowerCAmelCase_			:      Union[str, Any]			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      str			=   argparse.ArgumentParser()
      expected.add_argument("""--foo_int"""    ,						nargs="""+"""    ,						default=[]    ,						type=lowerCamelCase		)
      expected.add_argument("""--bar_int"""    ,						nargs="""+"""    ,						default=[1, 2, 3]    ,						type=lowerCamelCase		)
      expected.add_argument("""--foo_str"""    ,						nargs="""+"""    ,						default=["""Hallo""", """Bonjour""", """Hello"""]    ,						type=lowerCamelCase		)
      expected.add_argument("""--foo_float"""    ,						nargs="""+"""    ,						default=[0.1, 0.2, 0.3]    ,						type=lowerCamelCase		)

      self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

      lowerCAmelCase_			:      int			=   parser.parse_args([]		)
      self.assertEqual(
          lowerCamelCase    ,						Namespace(foo_int=[]    ,						bar_int=[1, 2, 3]    ,						foo_str=["""Hallo""", """Bonjour""", """Hello"""]    ,						foo_float=[0.1, 0.2, 0.3]		)    ,						)

      lowerCAmelCase_			:      Dict			=   parser.parse_args("""--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7""".split()		)
      self.assertEqual(lowerCamelCase    ,						Namespace(foo_int=[1]    ,						bar_int=[2, 3]    ,						foo_str=["""a""", """b""", """c"""]    ,						foo_float=[0.1, 0.7]		)		)

    def __lowercase   (   self    :  List[Any]		)   ->  List[Any]:
      lowerCAmelCase_			:      Tuple			=   argparse.ArgumentParser()
      expected.add_argument("""--foo"""    ,						default=lowerCamelCase    ,						type=lowerCamelCase		)
      expected.add_argument("""--bar"""    ,						default=lowerCamelCase    ,						type=lowerCamelCase    ,						help="""help message"""		)
      expected.add_argument("""--baz"""    ,						default=lowerCamelCase    ,						type=lowerCamelCase		)
      expected.add_argument("""--ces"""    ,						nargs="""+"""    ,						default=[]    ,						type=lowerCamelCase		)
      expected.add_argument("""--des"""    ,						nargs="""+"""    ,						default=[]    ,						type=lowerCamelCase		)

      lowerCAmelCase_			:      Union[str, Any]			=   [OptionalExample]
      if is_python_no_less_than_3_10:
        dataclass_types.append(lowerCamelCase		)

      for dataclass_type in dataclass_types:
        lowerCAmelCase_			:      str			=   HfArgumentParser(lowerCamelCase		)

        self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

        lowerCAmelCase_			:      Optional[int]			=   parser.parse_args([]		)
        self.assertEqual(lowerCamelCase    ,						Namespace(foo=lowerCamelCase    ,						bar=lowerCamelCase    ,						baz=lowerCamelCase    ,						ces=[]    ,						des=[]		)		)

        lowerCAmelCase_			:      Optional[Any]			=   parser.parse_args("""--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3""".split()		)
        self.assertEqual(lowerCamelCase    ,						Namespace(foo=12    ,						bar=3.14    ,						baz="""42"""    ,						ces=["""a""", """b""", """c"""]    ,						des=[1, 2, 3]		)		)

    def __lowercase   (   self    :  Dict		)   ->  Union[str, Any]:
      lowerCAmelCase_			:      Union[str, Any]			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      str			=   argparse.ArgumentParser()
      expected.add_argument("""--required_list"""    ,						nargs="""+"""    ,						type=lowerCamelCase    ,						required=lowerCamelCase		)
      expected.add_argument("""--required_str"""    ,						type=lowerCamelCase    ,						required=lowerCamelCase		)
      expected.add_argument(
          """--required_enum"""    ,						type=make_choice_type_function(["""titi""", """toto"""]		)    ,						choices=["""titi""", """toto"""]    ,						required=lowerCamelCase    ,						)
      self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

    def __lowercase   (   self    :  Optional[int]		)   ->  Dict:
      lowerCAmelCase_			:      Dict			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      List[str]			=   argparse.ArgumentParser()
      expected.add_argument("""--foo"""    ,						type=lowerCamelCase    ,						required=lowerCamelCase		)
      expected.add_argument(
          """--required_enum"""    ,						type=make_choice_type_function(["""titi""", """toto"""]		)    ,						choices=["""titi""", """toto"""]    ,						required=lowerCamelCase    ,						)
      expected.add_argument("""--opt"""    ,						type=lowerCamelCase    ,						default=lowerCamelCase		)
      expected.add_argument("""--baz"""    ,						default="""toto"""    ,						type=lowerCamelCase    ,						help="""help message"""		)
      expected.add_argument("""--foo_str"""    ,						nargs="""+"""    ,						default=["""Hallo""", """Bonjour""", """Hello"""]    ,						type=lowerCamelCase		)
      self.argparsersEqual(lowerCamelCase    ,						lowerCamelCase		)

    def __lowercase   (   self    :  Dict		)   ->  Optional[int]:
      lowerCAmelCase_			:      Optional[Any]			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      Tuple			=   {
          """foo""": 12,
          """bar""": 3.14,
          """baz""": """42""",
          """flag""": True,
      }

      lowerCAmelCase_			:      List[Any]			=   parser.parse_dict(lowerCamelCase		)[0]
      lowerCAmelCase_			:      str			=   BasicExample(**lowerCamelCase		)
      self.assertEqual(lowerCamelCase    ,						lowerCamelCase		)

    def __lowercase   (   self    :  Optional[Any]		)   ->  List[Any]:
      lowerCAmelCase_			:      int			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      List[Any]			=   {
          """foo""": 12,
          """bar""": 3.14,
          """baz""": """42""",
          """flag""": True,
          """extra""": 42,
      }

      self.assertRaises(lowerCamelCase    ,						parser.parse_dict    ,						lowerCamelCase    ,						allow_extra_keys=lowerCamelCase		)

    def __lowercase   (   self    :  List[str]		)   ->  Optional[Any]:
      lowerCAmelCase_			:      Optional[Any]			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      Optional[Any]			=   {
          """foo""": 12,
          """bar""": 3.14,
          """baz""": """42""",
          """flag""": True,
      }
      with tempfile.TemporaryDirectory() as tmp_dir:
        lowerCAmelCase_			:      Union[str, Any]			=   os.path.join(lowerCamelCase    ,						"""temp_json"""		)
        os.mkdir(lowerCamelCase		)
        with open(temp_local_path + """.json"""    ,						"""w+"""		) as f:
          json.dump(lowerCamelCase    ,						lowerCamelCase		)
        lowerCAmelCase_			:      Optional[int]			=   parser.parse_yaml_file(Path(temp_local_path + """.json"""		)		)[0]

      lowerCAmelCase_			:      Dict			=   BasicExample(**lowerCamelCase		)
      self.assertEqual(lowerCamelCase    ,						lowerCamelCase		)

    def __lowercase   (   self    :  Dict		)   ->  Tuple:
      lowerCAmelCase_			:      str			=   HfArgumentParser(lowerCamelCase		)

      lowerCAmelCase_			:      List[str]			=   {
          """foo""": 12,
          """bar""": 3.14,
          """baz""": """42""",
          """flag""": True,
      }
      with tempfile.TemporaryDirectory() as tmp_dir:
        lowerCAmelCase_			:      List[Any]			=   os.path.join(lowerCamelCase    ,						"""temp_yaml"""		)
        os.mkdir(lowerCamelCase		)
        with open(temp_local_path + """.yaml"""    ,						"""w+"""		) as f:
          yaml.dump(lowerCamelCase    ,						lowerCamelCase		)
        lowerCAmelCase_			:      List[str]			=   parser.parse_yaml_file(Path(temp_local_path + """.yaml"""		)		)[0]
      lowerCAmelCase_			:      Dict			=   BasicExample(**lowerCamelCase		)
      self.assertEqual(lowerCamelCase    ,						lowerCamelCase		)





    def __lowercase   (   self    :  Optional[int]		)   ->  Dict:
      lowerCAmelCase_			:      Any			=   HfArgumentParser(lowerCamelCase		)
      self.assertIsNotNone(lowerCamelCase		)







'''simple docstring'''






import json
import os
import unittest

from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES, BioGptTokenizer
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin






class    __snake_case       (   _SCREAMING_SNAKE_CASE	,unittest.TestCase):







    """simple docstring"""



    lowercase    =					BioGptTokenizer
    lowercase    =					False

    def __lowercase   (   self    :  List[Any]		)   ->  List[str]:
      super().setUp()

      # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
      lowerCAmelCase_			:      Optional[Any]			=   [
          """l""",
          """o""",
          """w""",
          """e""",
          """r""",
          """s""",
          """t""",
          """i""",
          """d""",
          """n""",
          """w</w>""",
          """r</w>""",
          """t</w>""",
          """lo""",
          """low""",
          """er</w>""",
          """low</w>""",
          """lowest</w>""",
          """newer</w>""",
          """wider</w>""",
          """<unk>""",
      ]
      lowerCAmelCase_			:      int			=   dict(zip(lowerCamelCase    ,						range(len(lowerCamelCase		)		)		)		)
      lowerCAmelCase_			:      int			=   ["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""]

      lowerCAmelCase_			:      Optional[int]			=   os.path.join(self.tmpdirname    ,						VOCAB_FILES_NAMES["""vocab_file"""]		)
      lowerCAmelCase_			:      Union[str, Any]			=   os.path.join(self.tmpdirname    ,						VOCAB_FILES_NAMES["""merges_file"""]		)
      with open(self.vocab_file    ,						"""w"""		) as fp:
        fp.write(json.dumps(lowerCamelCase		)		)
      with open(self.merges_file    ,						"""w"""		) as fp:
        fp.write("""\n""".join(lowerCamelCase		)		)

    def __lowercase   (   self    :  Union[str, Any]    ,						lowerCamelCase    :  Any		)   ->  List[str]:
      lowerCAmelCase_			:      Dict			=   """lower newer"""
      lowerCAmelCase_			:      str			=   """lower newer"""
      return input_text, output_text

    def __lowercase   (   self    :  Optional[int]		)   ->  str:
      lowerCAmelCase_			:      Any			=   BioGptTokenizer(self.vocab_file    ,						self.merges_file		)

      lowerCAmelCase_			:      int			=   """lower"""
      lowerCAmelCase_			:      str			=   ["""low""", """er</w>"""]
      lowerCAmelCase_			:      Any			=   tokenizer.tokenize(lowerCamelCase		)
      self.assertListEqual(lowerCamelCase    ,						lowerCamelCase		)

      lowerCAmelCase_			:      Dict			=   tokens + ["""<unk>"""]
      lowerCAmelCase_			:      Optional[Any]			=   [14, 15, 20]
      self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase		)    ,						lowerCamelCase		)





    @slow
    def __lowercase   (   self    :  str		)   ->  Optional[Any]:
      lowerCAmelCase_			:      Dict			=   BioGptTokenizer.from_pretrained("""microsoft/biogpt"""		)

      lowerCAmelCase_			:      int			=   tokenizer.encode("""sequence builders"""    ,						add_special_tokens=lowerCamelCase		)
      lowerCAmelCase_			:      Optional[Any]			=   tokenizer.encode("""multi-sequence build"""    ,						add_special_tokens=lowerCamelCase		)

      lowerCAmelCase_			:      str			=   tokenizer.build_inputs_with_special_tokens(lowerCamelCase		)
      lowerCAmelCase_			:      Optional[int]			=   tokenizer.build_inputs_with_special_tokens(lowerCamelCase    ,						lowerCamelCase		)

      self.assertTrue(encoded_sentence == [2] + text		)
      self.assertTrue(encoded_pair == [2] + text + [2] + text_a		)



