



"""simple docstring"""
import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, ByTaTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
      A:   Optional[Any]								=		"pt"
elif is_tf_available():
      A:   Tuple								=		"tf"
else:
      A:   Dict								=		"jax"



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   str						=						ByTaTokenizer
   __lowerCAmelCase  :   Optional[int]						=						False

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    super().setUp()
    UpperCAmelCase	:					Union[str, Any]	=	ByTaTokenizer()
    tokenizer.save_pretrained(self.tmpdirname						)

   @cached_property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    return ByTaTokenizer.from_pretrained("""google/byt5-small"""						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     **_SCREAMING_SNAKE_CASE						)  ->      ByTaTokenizer:





    '''simple docstring'''




    return self.tokenizer_class.from_pretrained(self.tmpdirname      ,     **_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=False      ,     _SCREAMING_SNAKE_CASE=20      ,     _SCREAMING_SNAKE_CASE=5						)  ->      Tuple[str, list]:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	[]
    for i in range(len(_SCREAMING_SNAKE_CASE						)						):
     try:
      UpperCAmelCase	:					Optional[Any]	=	tokenizer.decode([i]      ,     clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE						)
     except UnicodeDecodeError:
      pass
     toks.append((i, tok)						)

    UpperCAmelCase	:					int	=	list(filter(lambda _SCREAMING_SNAKE_CASE						: re.match(r"""^[ a-zA-Z]+$"""      ,     t[1]						)      ,     _SCREAMING_SNAKE_CASE						)						)
    UpperCAmelCase	:					Optional[int]	=	list(filter(lambda _SCREAMING_SNAKE_CASE						: [t[0]] == tokenizer.encode(t[1]      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)      ,     _SCREAMING_SNAKE_CASE						)						)
    if max_length is not None and len(_SCREAMING_SNAKE_CASE						) > max_length:
     UpperCAmelCase	:					Optional[Any]	=	toks[:max_length]
    if min_length is not None and len(_SCREAMING_SNAKE_CASE						) < min_length and len(_SCREAMING_SNAKE_CASE						) > 0:
     while len(_SCREAMING_SNAKE_CASE						) < min_length:
      UpperCAmelCase	:					Dict	=	toks + toks
        # toks_str = [t[1] for t in toks]
    UpperCAmelCase	:					str	=	[t[0] for t in toks]

    # Ensure consistency
    UpperCAmelCase	:					int	=	tokenizer.decode(_SCREAMING_SNAKE_CASE      ,     clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE						)
    if " " not in output_txt and len(_SCREAMING_SNAKE_CASE						) > 1:
     UpperCAmelCase	:					Optional[Any]	=	(
         tokenizer.decode([toks_ids[0]]      ,     clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE						)
         + """ """
         + tokenizer.decode(toks_ids[1:]      ,     clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE						)
     )
    if with_prefix_space:
     UpperCAmelCase	:					Optional[int]	=	""" """ + output_txt
    UpperCAmelCase	:					int	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
    return output_txt, output_ids

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self.ta_base_tokenizer
    UpperCAmelCase	:					List[Any]	=	tokenizer(["""hi</s>""", """I went to the gym</s>""", """</s>"""]						)
    UpperCAmelCase	:					Any	=	tokenizer(["""hi""", """I went to the gym""", """"""]						)
    self.assertListEqual(batch_with_eos_added["""input_ids"""]      ,     batch_without_eos_added["""input_ids"""]						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self.ta_base_tokenizer
    UpperCAmelCase	:					Optional[Any]	=	"""Unicode €."""
    UpperCAmelCase	:					Union[str, Any]	=	tokenizer(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Union[str, Any]	=	[88, 113, 108, 102, 114, 103, 104, 35, 229, 133, 175, 49, 1]
    self.assertEqual(encoded["""input_ids"""]      ,     _SCREAMING_SNAKE_CASE						)

    # decoding
    UpperCAmelCase	:					Tuple	=	tokenizer.decode(_SCREAMING_SNAKE_CASE						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     """Unicode €.</s>"""						)

    UpperCAmelCase	:					Optional[int]	=	tokenizer("""e è é ê ë"""						)
    UpperCAmelCase	:					int	=	[104, 35, 198, 171, 35, 198, 172, 35, 198, 173, 35, 198, 174, 1]
    self.assertEqual(encoded["""input_ids"""]      ,     _SCREAMING_SNAKE_CASE						)
    # decoding
    UpperCAmelCase	:					List[str]	=	tokenizer.decode(_SCREAMING_SNAKE_CASE						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     """e è é ê ë</s>"""						)

    # encode/decode, but with `encode` instead of `__call__`
    self.assertEqual(tokenizer.decode(tokenizer.encode("""e è é ê ë"""						)						)      ,     """e è é ê ë</s>"""						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					List[Any]	=	self.ta_base_tokenizer
    UpperCAmelCase	:					str	=	["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
    # fmt: off
    UpperCAmelCase	:					int	=	[68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 1, 0]
    # fmt: on
    UpperCAmelCase	:					Optional[int]	=	tokenizer(_SCREAMING_SNAKE_CASE      ,     padding=_SCREAMING_SNAKE_CASE      ,     return_tensors=_SCREAMING_SNAKE_CASE						)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    if FRAMEWORK != "jax":
     UpperCAmelCase	:					int	=	list(batch.input_ids.numpy()[0]						)
    else:
     UpperCAmelCase	:					str	=	list(batch.input_ids.tolist()[0]						)

    self.assertListEqual(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    self.assertEqual((2, 37)      ,     batch.input_ids.shape						)
    self.assertEqual((2, 37)      ,     batch.attention_mask.shape						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.ta_base_tokenizer
    UpperCAmelCase	:					Optional[int]	=	["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
    UpperCAmelCase	:					Dict	=	tokenizer(_SCREAMING_SNAKE_CASE      ,     padding=_SCREAMING_SNAKE_CASE      ,     return_tensors=_SCREAMING_SNAKE_CASE						)
    # check if input_ids are returned and no decoder_input_ids
    self.assertIn("""input_ids"""      ,     _SCREAMING_SNAKE_CASE						)
    self.assertIn("""attention_mask"""      ,     _SCREAMING_SNAKE_CASE						)
    self.assertNotIn("""decoder_input_ids"""      ,     _SCREAMING_SNAKE_CASE						)
    self.assertNotIn("""decoder_attention_mask"""      ,     _SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self.ta_base_tokenizer
    UpperCAmelCase	:					List[str]	=	[
        """Summary of the text.""",
        """Another summary.""",
    ]
    UpperCAmelCase	:					Tuple	=	tokenizer(
        text_target=_SCREAMING_SNAKE_CASE      ,     max_length=32      ,     padding="""max_length"""      ,     truncation=_SCREAMING_SNAKE_CASE      ,     return_tensors=_SCREAMING_SNAKE_CASE						)
    self.assertEqual(32      ,     targets["""input_ids"""].shape[1]						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self.ta_base_tokenizer
    UpperCAmelCase	:					str	=	["""A long paragraph for summarization. </s>"""]
    UpperCAmelCase	:					List[Any]	=	["""Summary of the text. </s>"""]
    # fmt: off
    UpperCAmelCase	:					Dict	=	[68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 35, 1]
    UpperCAmelCase	:					int	=	[86, 120, 112, 112, 100, 117, 124, 35, 114, 105, 35, 119, 107, 104, 35, 119, 104, 123, 119, 49, 35, 1]
    # fmt: on

    UpperCAmelCase	:					Any	=	tokenizer(_SCREAMING_SNAKE_CASE      ,     text_target=_SCREAMING_SNAKE_CASE						)

    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     batch["""input_ids"""][0]						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     batch["""labels"""][0]						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.get_tokenizers()
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      self.assertNotEqual(tokenizer.model_max_length      ,     42						)

        # Now let's start the test
    UpperCAmelCase	:					Any	=	self.get_tokenizers()
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      # Isolate this from the other tests because we save additional tokens/etc
      UpperCAmelCase	:					Optional[int]	=	tempfile.mkdtemp()

      UpperCAmelCase	:					List[str]	=	""" He is very happy, UNwant\u00E9d,running"""
      UpperCAmelCase	:					List[str]	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					Tuple	=	tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					Any	=	after_tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

      shutil.rmtree(_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					Optional[int]	=	self.get_tokenizers(model_max_length=42						)
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      # Isolate this from the other tests because we save additional tokens/etc
      UpperCAmelCase	:					Any	=	tempfile.mkdtemp()

      UpperCAmelCase	:					List[str]	=	""" He is very happy, UNwant\u00E9d,running"""
      tokenizer.add_tokens(["""bim""", """bambam"""]						)
      UpperCAmelCase	:					Dict	=	tokenizer.additional_special_tokens
      additional_special_tokens.append("""new_additional_special_token"""						)
      tokenizer.add_special_tokens({"""additional_special_tokens""": additional_special_tokens}						)
      UpperCAmelCase	:					List[str]	=	tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					Dict	=	tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					str	=	after_tokenizer.encode(_SCREAMING_SNAKE_CASE      ,     add_special_tokens=_SCREAMING_SNAKE_CASE						)
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
      self.assertIn("""new_additional_special_token"""      ,     after_tokenizer.additional_special_tokens						)
      self.assertEqual(after_tokenizer.model_max_length      ,     42						)

      UpperCAmelCase	:					Optional[int]	=	tokenizer.__class__.from_pretrained(_SCREAMING_SNAKE_CASE      ,     model_max_length=43						)
      self.assertEqual(tokenizer.model_max_length      ,     43						)

      shutil.rmtree(_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					List[Any]	=	[]
    if self.test_slow_tokenizer:
     tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())						)

    if self.test_rust_tokenizer:
     tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())						)

    for tokenizer_class, tokenizer_utils in tokenizer_list:
     with tempfile.TemporaryDirectory() as tmp_dir:
      tokenizer_utils.save_pretrained(_SCREAMING_SNAKE_CASE						)

      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """special_tokens_map.json"""						)      ,     encoding="""utf-8"""						) as json_file:
       UpperCAmelCase	:					int	=	json.load(_SCREAMING_SNAKE_CASE						)

      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """tokenizer_config.json"""						)      ,     encoding="""utf-8"""						) as json_file:
       UpperCAmelCase	:					List[Any]	=	json.load(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					List[Any]	=	[F"<extra_id_{i}>" for i in range(125						)]

      UpperCAmelCase	:					Optional[Any]	=	added_tokens_extra_ids + [
          """an_additional_special_token"""
      ]
      UpperCAmelCase	:					List[str]	=	added_tokens_extra_ids + [
          """an_additional_special_token"""
      ]

      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """special_tokens_map.json"""						)      ,     """w"""      ,     encoding="""utf-8"""						) as outfile:
       json.dump(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
      with open(os.path.join(_SCREAMING_SNAKE_CASE      ,     """tokenizer_config.json"""						)      ,     """w"""      ,     encoding="""utf-8"""						) as outfile:
       json.dump(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

      # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
      # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
      # "special_tokens_map.json" files
      UpperCAmelCase	:					List[str]	=	tokenizer_class.from_pretrained(
          _SCREAMING_SNAKE_CASE      ,     )
      self.assertIn(
          """an_additional_special_token"""      ,     tokenizer_without_change_in_init.additional_special_tokens						)
      # self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
      self.assertEqual(
          ["""an_additional_special_token"""]      ,     tokenizer_without_change_in_init.convert_ids_to_tokens(
              tokenizer_without_change_in_init.convert_tokens_to_ids(["""an_additional_special_token"""]						)						)      ,     )

      # Now we test that we can change the value of additional_special_tokens in the from_pretrained
      UpperCAmelCase	:					List[str]	=	added_tokens_extra_ids + [AddedToken("""a_new_additional_special_token"""      ,     lstrip=_SCREAMING_SNAKE_CASE						)]
      UpperCAmelCase	:					List[str]	=	tokenizer_class.from_pretrained(
          _SCREAMING_SNAKE_CASE      ,     additional_special_tokens=_SCREAMING_SNAKE_CASE      ,     )

      self.assertIn("""a_new_additional_special_token"""      ,     tokenizer.additional_special_tokens						)
      self.assertEqual(
          ["""a_new_additional_special_token"""]      ,     tokenizer.convert_ids_to_tokens(
              tokenizer.convert_tokens_to_ids(["""a_new_additional_special_token"""]						)						)      ,     )

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	[]
    if self.test_slow_tokenizer:
     tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())						)

    if self.test_rust_tokenizer:
     tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())						)

    for tokenizer_class, tokenizer_utils in tokenizer_list:
     with tempfile.TemporaryDirectory() as tmp_dir:
      tokenizer_utils.save_pretrained(_SCREAMING_SNAKE_CASE						)

      UpperCAmelCase	:					Optional[int]	=	tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE						)

      self.assertTrue(tokenizer.decode([255]						) == """"""						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.get_tokenizers(fast=_SCREAMING_SNAKE_CASE      ,     do_lower_case=_SCREAMING_SNAKE_CASE						)
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      UpperCAmelCase	:					Union[str, Any]	=	["""t""", """h""", """i""", """s""", """ """, """i""", """s""", """ """, """a""", """ """, """t""", """e""", """x""", """t""", """</s>"""]
      UpperCAmelCase	:					Union[str, Any]	=	tokenizer.convert_tokens_to_string(_SCREAMING_SNAKE_CASE						)

      self.assertIsInstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.get_tokenizers()
    for tokenizer in tokenizers:
     with self.subTest(F"{tokenizer.__class__.__name__}"						):
      UpperCAmelCase	:					Dict	=	[
          """bos_token""",
          """eos_token""",
          """unk_token""",
          """sep_token""",
          """pad_token""",
          """cls_token""",
          """mask_token""",
      ]

      UpperCAmelCase	:					Dict	=	0
      UpperCAmelCase	:					Union[str, Any]	=	tokenizer.convert_ids_to_tokens(
          _SCREAMING_SNAKE_CASE      ,     skip_special_tokens=_SCREAMING_SNAKE_CASE						)

      for attr in attributes_list:
       setattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""      ,     _SCREAMING_SNAKE_CASE						)
       self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)      ,     _SCREAMING_SNAKE_CASE						)
       self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""						)      ,     _SCREAMING_SNAKE_CASE						)

       setattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""      ,     _SCREAMING_SNAKE_CASE						)
       self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)      ,     _SCREAMING_SNAKE_CASE						)
       self.assertEqual(getattr(_SCREAMING_SNAKE_CASE      ,     attr + """_id"""						)      ,     _SCREAMING_SNAKE_CASE						)

      setattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""      ,     []						)
      self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens"""						)      ,     []						)
      self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""						)      ,     []						)

      setattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""      ,     [token_id_to_test_setters]						)
      self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens"""						)      ,     [token_to_test_setters]						)
      self.assertListEqual(getattr(_SCREAMING_SNAKE_CASE      ,     """additional_special_tokens_ids"""						)      ,     [token_id_to_test_setters]						)





"""simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from argparse import ArgumentParser

from accelerate.commands.config import get_config_parser
from accelerate.commands.env import env_command_parser
from accelerate.commands.launch import launch_command_parser
from accelerate.commands.test import test_command_parser
from accelerate.commands.tpu import tpu_command_parser

def       _snake_case						(						):
 UpperCAmelCase	:					List[str]	=	ArgumentParser("""Accelerate CLI tool"""			,		usage="""accelerate <command> [<args>]"""			,		allow_abbrev=UpperCamelCase						)
 UpperCAmelCase	:					Dict	=	parser.add_subparsers(help="""accelerate command helpers"""						)

 # Register commands
 get_config_parser(subparsers=UpperCamelCase						)
 env_command_parser(subparsers=UpperCamelCase						)
 launch_command_parser(subparsers=UpperCamelCase						)
 tpu_command_parser(subparsers=UpperCamelCase						)
 test_command_parser(subparsers=UpperCamelCase						)

 # Let's go
 UpperCAmelCase	:					Optional[int]	=	parser.parse_args()

 if not hasattr(UpperCamelCase			,		"""func"""						):
  parser.print_help()
  exit(1						)

 # Run
 args.func(UpperCamelCase						)


if __name__ == "__main__":
      main()
