




'''simple docstring'''






import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin






class        lowercase_      (						lowerCAmelCase_						,       unittest.TestCase							):
     A_											=			CanineTokenizer
     A_											=			False





     def 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           super().setUp()
           snake_case__       :   Union[str, Any]	      =    CanineTokenizer()
           tokenizer.save_pretrained(self.tmpdirname			)





     @cached_property
     def 			_lowerCAmelCase      (     self     :					List[str]			):
           return CanineTokenizer.from_pretrained('google/canine-s'			)





     def 			_lowerCAmelCase      (     self     :					Dict     ,							**__lowerCamelCase     :					Optional[Any]			):
           snake_case__       :   Any	      =    self.tokenizer_class.from_pretrained(self.tmpdirname     ,							**__lowerCamelCase			)
           snake_case__       :   Any	      =    1024
           return tokenizer





     @require_torch
     def 			_lowerCAmelCase      (     self     :					str			):
           snake_case__       :   List[Any]	      =    self.canine_tokenizer
           snake_case__       :   int	      =    ['Life is like a box of chocolates.', 'You never know what you\'re gonna get.']
           # fmt: off
           snake_case__       :   List[Any]	      =    [57344, 76, 105, 102, 101, 32, 105, 115, 32, 108, 105, 107, 101, 32, 97, 32, 98, 111, 120, 32, 111, 102, 32, 99, 104, 111, 99, 111, 108, 97, 116, 101, 115, 46, 57345, 0, 0, 0, 0]
           # fmt: on
           snake_case__       :   Optional[Any]	      =    tokenizer(__lowerCamelCase     ,							padding=__lowerCamelCase     ,							return_tensors='pt'			)
           self.assertIsInstance(__lowerCamelCase     ,							__lowerCamelCase			)

           snake_case__       :   Union[str, Any]	      =    list(batch.input_ids.numpy()[0]			)

           self.assertListEqual(__lowerCamelCase     ,							__lowerCamelCase			)

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





     @require_torch
     def 			_lowerCAmelCase      (     self     :					Optional[int]			):
           snake_case__       :   Optional[Any]	      =    self.canine_tokenizer
           snake_case__       :   Optional[int]	      =    ['Once there was a man.', 'He wrote a test in HuggingFace Tranformers.']
           snake_case__       :   List[str]	      =    tokenizer(__lowerCamelCase     ,							padding=__lowerCamelCase     ,							return_tensors='pt'			)
           # check if input_ids, attention_mask and token_type_ids are returned
           self.assertIn('input_ids'     ,							__lowerCamelCase			)
           self.assertIn('attention_mask'     ,							__lowerCamelCase			)
           self.assertIn('token_type_ids'     ,							__lowerCamelCase			)





     @require_torch
     def 			_lowerCAmelCase      (     self     :					Optional[Any]			):
           snake_case__       :   int	      =    self.canine_tokenizer
           snake_case__       :   Union[str, Any]	      =    [
               'What\'s the weater?',
               'It\'s about 25 degrees.',
           ]
           snake_case__       :   Union[str, Any]	      =    tokenizer(
               text_target=__lowerCamelCase     ,							max_length=32     ,							padding='max_length'     ,							truncation=__lowerCamelCase     ,							return_tensors='pt'			)
           self.assertEqual(32     ,							targets['input_ids'].shape[1]			)





     def 			_lowerCAmelCase      (     self     :					Any			):
           # safety check on max_len default value so we are sure the test works
           snake_case__       :   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
           snake_case__       :   Union[str, 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
                       snake_case__       :   Any	      =    tempfile.mkdtemp()

                       snake_case__       :   List[Any]	      =    ' He is very happy, UNwant\u00E9d,running'
                       snake_case__       :   Dict	      =    tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       tokenizer.save_pretrained(__lowerCamelCase			)

                       snake_case__       :   List[Any]	      =    tokenizer.__class__.from_pretrained(__lowerCamelCase			)
                       snake_case__       :   Tuple	      =    after_tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       self.assertListEqual(__lowerCamelCase     ,							__lowerCamelCase			)

                       shutil.rmtree(__lowerCamelCase			)

           snake_case__       :   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
                       snake_case__       :   str	      =    tempfile.mkdtemp()

                       snake_case__       :   int	      =    ' He is very happy, UNwant\u00E9d,running'

                       snake_case__       :   int	      =    tokenizer.additional_special_tokens

                       # We can add a new special token for Canine as follows:
                       snake_case__       :   List[Any]	      =    chr(0XE_007			)
                       additional_special_tokens.append(__lowerCamelCase			)
                       tokenizer.add_special_tokens({'additional_special_tokens': additional_special_tokens}			)
                       snake_case__       :   str	      =    tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       tokenizer.save_pretrained(__lowerCamelCase			)

                       snake_case__       :   List[str]	      =    tokenizer.__class__.from_pretrained(__lowerCamelCase			)
                       snake_case__       :   Dict	      =    after_tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       self.assertListEqual(__lowerCamelCase     ,							__lowerCamelCase			)
                       self.assertIn(__lowerCamelCase     ,							after_tokenizer.additional_special_tokens			)
                       self.assertEqual(after_tokenizer.model_max_length     ,							42			)

                       snake_case__       :   List[str]	      =    tokenizer.__class__.from_pretrained(__lowerCamelCase     ,							model_max_length=43			)
                       self.assertEqual(tokenizer.model_max_length     ,							43			)

                       shutil.rmtree(__lowerCamelCase			)





     def 			_lowerCAmelCase      (     self     :					Optional[int]			):
           snake_case__       :   Union[str, Any]	      =    self.get_tokenizers(do_lower_case=__lowerCamelCase			)
           for tokenizer in tokenizers:
                 with self.subTest(F"{tokenizer.__class__.__name__}"			):
                       snake_case__      ,							snake_case__       :   Union[str, Any]	      =    self.get_clean_sequence(__lowerCamelCase			)

                       # a special token for Canine can be defined as follows:
                       snake_case__       :   Any	      =    0XE_005
                       snake_case__       :   Tuple	      =    chr(__lowerCamelCase			)

                       tokenizer.add_special_tokens({'cls_token': special_token}			)
                       snake_case__       :   int	      =    tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       self.assertEqual(len(__lowerCamelCase			)     ,							1			)

                       snake_case__       :   Any	      =    tokenizer.decode(ids + encoded_special_token     ,							clean_up_tokenization_spaces=__lowerCamelCase			)
                       snake_case__       :   Optional[int]	      =    tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)

                       snake_case__       :   List[Any]	      =    tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       snake_case__       :   Dict	      =    tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       self.assertEqual(__lowerCamelCase     ,							input_encoded + special_token_id			)

                       snake_case__       :   Union[str, Any]	      =    tokenizer.decode(__lowerCamelCase     ,							skip_special_tokens=__lowerCamelCase			)
                       self.assertTrue(special_token not in decoded			)





     def 			_lowerCAmelCase      (     self     :					Tuple			):
           snake_case__       :   str	      =    self.get_tokenizers(do_lower_case=__lowerCamelCase			)
           for tokenizer in tokenizers:
                 with self.subTest(F"{tokenizer.__class__.__name__}"			):
                       snake_case__       :   str	      =    chr(0XE_005			)
                       snake_case__       :   Optional[Any]	      =    chr(0XE_006			)

                       # `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
                       tokenizer.add_tokens([SPECIAL_TOKEN_1]     ,							special_tokens=__lowerCamelCase			)
                       # `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
                       # which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
                       tokenizer.add_special_tokens({'additional_special_tokens': [SPECIAL_TOKEN_2]}			)

                       snake_case__       :   List[Any]	      =    tokenizer.tokenize(__lowerCamelCase			)
                       snake_case__       :   List[Any]	      =    tokenizer.tokenize(__lowerCamelCase			)

                       self.assertEqual(len(__lowerCamelCase			)     ,							1			)
                       self.assertEqual(len(__lowerCamelCase			)     ,							1			)
                       self.assertEqual(token_a[0]     ,							__lowerCamelCase			)
                       self.assertEqual(token_a[0]     ,							__lowerCamelCase			)





     @require_tokenizers
     def 			_lowerCAmelCase      (     self     :					Dict			):
           snake_case__       :   Dict	      =    self.get_tokenizers(do_lower_case=__lowerCamelCase			)
           for tokenizer in tokenizers:
                 with self.subTest(F"{tokenizer.__class__.__name__}"			):
                       # a special token for Canine can be defined as follows:
                       snake_case__       :   int	      =    0XE_006
                       snake_case__       :   str	      =    chr(__lowerCamelCase			)

                       snake_case__       :   int	      =    AddedToken(__lowerCamelCase     ,							lstrip=__lowerCamelCase			)
                       tokenizer.add_special_tokens({'additional_special_tokens': [new_token]}			)

                       with tempfile.TemporaryDirectory() as tmp_dir_name:
                             tokenizer.save_pretrained(__lowerCamelCase			)
                             tokenizer.from_pretrained(__lowerCamelCase			)





     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           snake_case__       :   Dict	      =    []
           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(__lowerCamelCase			)

                       with open(os.path.join(__lowerCamelCase     ,							'special_tokens_map.json'			)     ,							encoding='utf-8'			) as json_file:
                             snake_case__       :   Any	      =    json.load(__lowerCamelCase			)

                       with open(os.path.join(__lowerCamelCase     ,							'tokenizer_config.json'			)     ,							encoding='utf-8'			) as json_file:
                             snake_case__       :   Any	      =    json.load(__lowerCamelCase			)

                       # a special token for Canine can be defined as follows:
                       snake_case__       :   Optional[int]	      =    0XE_006
                       snake_case__       :   List[str]	      =    chr(__lowerCamelCase			)

                       snake_case__       :   List[Any]	      =    [new_token_a]
                       snake_case__       :   str	      =    [new_token_a]

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

                       # 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
                       snake_case__       :   List[str]	      =    tokenizer_class.from_pretrained(__lowerCamelCase     ,							extra_ids=0			)
                       self.assertIn(__lowerCamelCase     ,							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(
                           [new_token_a]     ,							tokenizer_without_change_in_init.convert_ids_to_tokens(
                               tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]			)			)     ,							)

                       snake_case__       :   int	      =    0XE_007
                       snake_case__       :   Tuple	      =    chr(__lowerCamelCase			)
                       # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                       snake_case__       :   Any	      =    [AddedToken(__lowerCamelCase     ,							lstrip=__lowerCamelCase			)]
                       snake_case__       :   Dict	      =    tokenizer_class.from_pretrained(
                           __lowerCamelCase     ,							additional_special_tokens=__lowerCamelCase     ,							extra_ids=0			)

                       self.assertIn(__lowerCamelCase     ,							tokenizer.additional_special_tokens			)
                       # self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
                       self.assertEqual(
                           [new_token_a]     ,							tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]			)			)			)





     @require_tokenizers
     def 			_lowerCAmelCase      (     self     :					int			):
           snake_case__       :   Optional[int]	      =    self.get_tokenizers(do_lower_case=__lowerCamelCase			)
           for tokenizer in tokenizers:
                 with self.subTest(F"{tokenizer.__class__.__name__}"			):
                       snake_case__       :   Any	      =    'hello world'
                       if self.space_between_special_tokens:
                             snake_case__       :   List[str]	      =    '[CLS] hello world [SEP]'
                       else:
                             snake_case__       :   str	      =    input
                       snake_case__       :   int	      =    tokenizer.encode(__lowerCamelCase     ,							add_special_tokens=__lowerCamelCase			)
                       snake_case__       :   Dict	      =    tokenizer.decode(__lowerCamelCase     ,							spaces_between_special_tokens=self.space_between_special_tokens			)
                       self.assertIn(__lowerCamelCase     ,							[output, output.lower()]			)





     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           snake_case__       :   str	      =    self.get_tokenizers()
           for tokenizer in tokenizers:
                 with self.subTest(F"{tokenizer.__class__.__name__}"			):
                       snake_case__       :   Tuple	      =    [
                           'bos_token',
                           'eos_token',
                           'unk_token',
                           'sep_token',
                           'pad_token',
                           'cls_token',
                           'mask_token',
                       ]

           snake_case__       :   Union[str, Any]	      =    'a'
           snake_case__       :   Optional[Any]	      =    ord(__lowerCamelCase			)

           for attr in attributes_list:
                 setattr(__lowerCamelCase     ,							attr + '_id'     ,							__lowerCamelCase			)
                 self.assertEqual(getattr(__lowerCamelCase     ,							__lowerCamelCase			)     ,							__lowerCamelCase			)
                 self.assertEqual(getattr(__lowerCamelCase     ,							attr + '_id'			)     ,							__lowerCamelCase			)

                 setattr(__lowerCamelCase     ,							attr + '_id'     ,							__lowerCamelCase			)
                 self.assertEqual(getattr(__lowerCamelCase     ,							__lowerCamelCase			)     ,							__lowerCamelCase			)
                 self.assertEqual(getattr(__lowerCamelCase     ,							attr + '_id'			)     ,							__lowerCamelCase			)

           setattr(__lowerCamelCase     ,							'additional_special_tokens_ids'     ,							[]			)
           self.assertListEqual(getattr(__lowerCamelCase     ,							'additional_special_tokens'			)     ,							[]			)
           self.assertListEqual(getattr(__lowerCamelCase     ,							'additional_special_tokens_ids'			)     ,							[]			)

           snake_case__       :   str	      =    0XE_006
           snake_case__       :   List[Any]	      =    chr(__lowerCamelCase			)
           setattr(__lowerCamelCase     ,							'additional_special_tokens_ids'     ,							[additional_special_token_id]			)
           self.assertListEqual(getattr(__lowerCamelCase     ,							'additional_special_tokens'			)     ,							[additional_special_token]			)
           self.assertListEqual(getattr(__lowerCamelCase     ,							'additional_special_tokens_ids'			)     ,							[additional_special_token_id]			)





     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           pass





     def 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           pass





     def 			_lowerCAmelCase      (     self     :					Optional[Any]			):
           pass





     def 			_lowerCAmelCase      (     self     :					int			):
           pass





     def 			_lowerCAmelCase      (     self     :					Any			):
           pass





     def 			_lowerCAmelCase      (     self     :					Optional[int]			):
           pass





     def 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           pass





     def 			_lowerCAmelCase      (     self     :					Optional[Any]			):
           pass






'''simple docstring'''






# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py

import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		)    ->   Dict:
      snake_case__       :   int	      =    multiprocessing.Manager()
      snake_case__       :   Any	      =    manager.list()

      snake_case__       :   List[str]	      =    multiprocessing.Process(target=__SCREAMING_SNAKE_CASE				,      args=(check_program, result, timeout)		)
      p.start()
      p.join(timeout=timeout + 1		)
      if p.is_alive():
            p.kill()

      if not result:
            result.append('timed out'		)

      return {
          "task_id": task_id,
          "passed": result[0] == "passed",
          "result": result[0],
          "completion_id": completion_id,
      }






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		)    ->   Tuple:
      with create_tempdir():
            # These system calls are needed when cleaning up tempdir.
            import os
            import shutil

            snake_case__       :   List[Any]	      =    shutil.rmtree
            snake_case__       :   Tuple	      =    os.rmdir
            snake_case__       :   Any	      =    os.chdir

            # Disable functionalities that can make destructive changes to the test.
            reliability_guard()

            # Run program.
            try:
                  snake_case__       :   Union[str, Any]	      =    {}
                  with swallow_io():
                        with time_limit(__SCREAMING_SNAKE_CASE		):
                              exec(__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		)
                  result.append('passed'		)
            except TimeoutException:
                  result.append('timed out'		)
            except BaseException as e:
                  result.append(f"failed: {e}"		)

            # Needed for cleaning up.
            snake_case__       :   List[Any]	      =    rmtree
            snake_case__       :   Optional[int]	      =    rmdir
            snake_case__       :   Dict	      =    chdir






@contextlib.contextmanager
def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   List[str]:
      def signal_handler(__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		):
            raise TimeoutException('Timed out!'		)

      signal.setitimer(signal.ITIMER_REAL				,      __SCREAMING_SNAKE_CASE		)
      signal.signal(signal.SIGALRM				,      __SCREAMING_SNAKE_CASE		)
      try:
            yield
      finally:
            signal.setitimer(signal.ITIMER_REAL				,      0		)






@contextlib.contextmanager
def 		UpperCamelCase__      (		)    ->   List[str]:
      snake_case__       :   Dict	      =    WriteOnlyStringIO()
      with contextlib.redirect_stdout(__SCREAMING_SNAKE_CASE		):
            with contextlib.redirect_stderr(__SCREAMING_SNAKE_CASE		):
                  with redirect_stdin(__SCREAMING_SNAKE_CASE		):
                        yield






@contextlib.contextmanager
def 		UpperCamelCase__      (		)    ->   Optional[int]:
      with tempfile.TemporaryDirectory() as dirname:
            with chdir(__SCREAMING_SNAKE_CASE		):
                  yield dirname






class        lowercase_      (						lowerCAmelCase_							):
     pass






class        lowercase_      (						io.StringIO							):





     def 			_lowerCAmelCase      (     self     :					Optional[Any]     ,							*__lowerCamelCase     :					int     ,							**__lowerCamelCase     :					Optional[int]			):
           raise OSError





     def 			_lowerCAmelCase      (     self     :					int     ,							*__lowerCamelCase     :					List[Any]     ,							**__lowerCamelCase     :					Tuple			):
           raise OSError





     def 			_lowerCAmelCase      (     self     :					Any     ,							*__lowerCamelCase     :					int     ,							**__lowerCamelCase     :					Union[str, Any]			):
           raise OSError





     def 			_lowerCAmelCase      (     self     :					Tuple     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					Optional[Any]			):
           return False






class        lowercase_      (						contextlib._RedirectStream							):  # type: ignore
     A_											=			"stdin"






@contextlib.contextmanager
def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   List[str]:
      if root == ".":
            yield
            return
      snake_case__       :   str	      =    os.getcwd()
      os.chdir(__SCREAMING_SNAKE_CASE		)
      try:
            yield
      except BaseException as exc:
            raise exc
      finally:
            os.chdir(__SCREAMING_SNAKE_CASE		)






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE=None		)    ->   Any:

      if maximum_memory_bytes is not None:
            import resource

            resource.setrlimit(resource.RLIMIT_AS				,      (maximum_memory_bytes, maximum_memory_bytes)		)
            resource.setrlimit(resource.RLIMIT_DATA				,      (maximum_memory_bytes, maximum_memory_bytes)		)
            if not platform.uname().system == "Darwin":
                  resource.setrlimit(resource.RLIMIT_STACK				,      (maximum_memory_bytes, maximum_memory_bytes)		)

      faulthandler.disable()

      import builtins

      snake_case__       :   List[Any]	      =    None
      snake_case__       :   List[str]	      =    None

      import os

      snake_case__       :   List[Any]	      =    '1'

      snake_case__       :   Union[str, Any]	      =    None
      snake_case__       :   Tuple	      =    None
      snake_case__       :   Dict	      =    None
      snake_case__       :   Tuple	      =    None
      snake_case__       :   List[str]	      =    None
      snake_case__       :   Any	      =    None
      snake_case__       :   Optional[Any]	      =    None
      snake_case__       :   Union[str, Any]	      =    None
      snake_case__       :   int	      =    None
      snake_case__       :   Optional[int]	      =    None
      snake_case__       :   Union[str, Any]	      =    None
      snake_case__       :   List[Any]	      =    None
      snake_case__       :   Optional[int]	      =    None
      snake_case__       :   Union[str, Any]	      =    None
      snake_case__       :   Tuple	      =    None
      snake_case__       :   int	      =    None
      snake_case__       :   Optional[Any]	      =    None
      snake_case__       :   Optional[int]	      =    None
      snake_case__       :   List[str]	      =    None
      snake_case__       :   List[str]	      =    None
      snake_case__       :   List[str]	      =    None
      snake_case__       :   Dict	      =    None
      snake_case__       :   Optional[Any]	      =    None
      snake_case__       :   List[Any]	      =    None
      snake_case__       :   Tuple	      =    None
      snake_case__       :   Optional[int]	      =    None
      snake_case__       :   int	      =    None

      import shutil

      snake_case__       :   List[str]	      =    None
      snake_case__       :   List[Any]	      =    None
      snake_case__       :   List[Any]	      =    None

      import subprocess

      snake_case__       :   int	      =    None  # type: ignore

      snake_case__       :   Dict	      =    None

      import sys

      snake_case__       :   Tuple	      =    None
      snake_case__       :   Tuple	      =    None
      snake_case__       :   List[str]	      =    None
      snake_case__       :   Optional[int]	      =    None
      snake_case__       :   List[Any]	      =    None
