


import unittest

from transformers import BertGenerationTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCAmelCase : Any 			=				"▁"

__UpperCAmelCase : int 			=				get_tests_dir("fixtures/test_sentencepiece.model")



@require_sentencepiece
class    UpperCAmelCase_	(							_a,     unittest.TestCase):
       '''simple docstring'''
       __UpperCamelCase      :     Any							=					BertGenerationTokenizer
       __UpperCamelCase      :     int							=					False
       __UpperCamelCase      :     List[Any]							=					True






       def  _lowercase   (     self						):




              """simple docstring"""




              super().setUp()

              UpperCamelCase    :	Tuple   	=		BertGenerationTokenizer(__SCREAMING_SNAKE_CASE ,					keep_accents=__SCREAMING_SNAKE_CASE						)
              tokenizer.save_pretrained(self.tmpdirname						)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Tuple   	=		'''<s>'''
              UpperCamelCase    :	Dict   	=		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  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Union[str, Any]   	=		list(self.get_tokenizer().get_vocab().keys()						)

              self.assertEqual(vocab_keys[0] ,					'''<unk>'''						)
              self.assertEqual(vocab_keys[1] ,					'''<s>'''						)
              self.assertEqual(vocab_keys[-1] ,					'''<pad>'''						)
              self.assertEqual(len(__SCREAMING_SNAKE_CASE						) ,					1_002						)






       def  _lowercase   (     self						):




              """simple docstring"""




              self.assertEqual(self.get_tokenizer().vocab_size ,					1_000						)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	int   	=		BertGenerationTokenizer(__SCREAMING_SNAKE_CASE ,					keep_accents=__SCREAMING_SNAKE_CASE						)

              UpperCamelCase    :	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						) ,					[285, 46, 10, 170, 382] ,					)

              UpperCamelCase    :	List[str]   	=		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''',
                      '''é''',
                      '''.''',
                  ] ,					)
              UpperCamelCase    :	Optional[Any]   	=		tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE						)
              self.assertListEqual(
                  __SCREAMING_SNAKE_CASE ,					[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4] ,					)

              UpperCamelCase    :	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  _lowercase   (     self						):




              """simple docstring"""




              return BertGenerationTokenizer.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder'''						)






       @slow
       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Optional[int]   	=		'''Hello World!'''
              UpperCamelCase    :	str   	=		[18_536, 2_260, 101]

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






       @slow
       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Optional[int]   	=		(
                  '''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'''
              )
              UpperCamelCase    :	Tuple   	=		[
                  871,
                  419,
                  358,
                  946,
                  991,
                  2_521,
                  452,
                  358,
                  1_357,
                  387,
                  7_751,
                  3_536,
                  112,
                  985,
                  456,
                  126,
                  865,
                  938,
                  5_400,
                  5_734,
                  458,
                  1_368,
                  467,
                  786,
                  2_462,
                  5_246,
                  1_159,
                  633,
                  865,
                  4_519,
                  457,
                  582,
                  852,
                  2_557,
                  427,
                  916,
                  508,
                  405,
                  34_324,
                  497,
                  391,
                  408,
                  11_342,
                  1_244,
                  385,
                  100,
                  938,
                  985,
                  456,
                  574,
                  362,
                  12_597,
                  3_200,
                  3_129,
                  1_172,
              ]

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






       @require_torch
       @slow
       def  _lowercase   (     self						):




              """simple docstring"""




              import torch

              from transformers import BertGenerationConfig, BertGenerationEncoder

              # Build sequence
              UpperCamelCase    :	Optional[Any]   	=		list(self.big_tokenizer.get_vocab().keys()						)[:10]
              UpperCamelCase    :	List[Any]   	=		''' '''.join(__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	Tuple   	=		self.big_tokenizer.encode_plus(__SCREAMING_SNAKE_CASE ,					return_tensors='''pt''' ,					return_token_type_ids=__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	List[Any]   	=		self.big_tokenizer.batch_encode_plus(
                  [sequence + ''' ''' + sequence] ,					return_tensors='''pt''' ,					return_token_type_ids=__SCREAMING_SNAKE_CASE						)

              UpperCamelCase    :	Optional[Any]   	=		BertGenerationConfig()
              UpperCamelCase    :	List[str]   	=		BertGenerationEncoder(__SCREAMING_SNAKE_CASE						)

              assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

              with torch.no_grad():
                     model(**__SCREAMING_SNAKE_CASE						)
                     model(**__SCREAMING_SNAKE_CASE						)






       @slow
       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Optional[Any]   	=		{'''input_ids''': [[39_286, 458, 36_335, 2_001, 456, 13_073, 13_266, 455, 113, 7_746, 1_741, 11_157, 391, 13_073, 13_266, 455, 113, 3_967, 35_412, 113, 4_936, 109, 3_870, 2_377, 113, 30_084, 45_720, 458, 134, 17_496, 112, 503, 11_672, 113, 118, 112, 5_665, 13_347, 38_687, 112, 1_496, 31_389, 112, 3_268, 47_264, 134, 962, 112, 16_377, 8_035, 23_130, 430, 12_169, 15_518, 28_592, 458, 146, 41_697, 109, 391, 12_169, 15_518, 16_689, 458, 146, 41_358, 109, 452, 726, 4_034, 111, 763, 35_412, 5_082, 388, 1_903, 111, 9_051, 391, 2_870, 48_918, 1_900, 1_123, 550, 998, 112, 9_586, 15_985, 455, 391, 410, 22_955, 37_636, 114], [448, 17_496, 419, 3_663, 385, 763, 113, 27_533, 2_870, 3_283, 13_043, 1_639, 24_713, 523, 656, 24_013, 18_550, 2_521, 517, 27_014, 21_244, 420, 1_212, 1_465, 391, 927, 4_833, 388, 578, 11_786, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [484, 2_169, 7_687, 21_932, 18_146, 726, 363, 17_032, 3_391, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
              # fmt: on

              self.tokenizer_integration_test_util(
                  expected_encoding=__SCREAMING_SNAKE_CASE ,					model_name='''google/bert_for_seq_generation_L-24_bbc_encoder''' ,					revision='''c817d1fd1be2ffa69431227a1fe320544943d4db''' ,					)





import json
import os
import shutil
import warnings
from argparse import ArgumentParser, Namespace
from pathlib import Path
from typing import List

from ..utils import logging
from . import BaseTransformersCLICommand


try:
  from cookiecutter.main import cookiecutter

  __UpperCAmelCase : List[Any] 			=				True
except ImportError:
  __UpperCAmelCase : List[str] 			=				False

__UpperCAmelCase : Any 			=				logging.get_logger(__name__)  # pylint: disable=invalid-name


def      a	(							SCREAMING_SNAKE_CASE_      :		Namespace       ):






       """simple docstring"""





       return AddNewModelCommand(args.testing							,			args.testing_file							,			path=args.path       )



class    UpperCAmelCase_	(							_a):
       '''simple docstring'''






       @staticmethod
       def  _lowercase   (     __SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	List[Any]   	=		parser.add_parser('''add-new-model'''						)
              add_new_model_parser.add_argument('''--testing''' ,					action='''store_true''' ,					help='''If in testing mode.'''						)
              add_new_model_parser.add_argument('''--testing_file''' ,					type=__SCREAMING_SNAKE_CASE ,					help='''Configuration file on which to run.'''						)
              add_new_model_parser.add_argument(
                  '''--path''' ,					type=__SCREAMING_SNAKE_CASE ,					help='''Path to cookiecutter. Should only be used for testing purposes.'''						)
              add_new_model_parser.set_defaults(func=__SCREAMING_SNAKE_CASE						)






       def __init__(     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE=None ,					*__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	Tuple   	=		testing
              UpperCamelCase    :	Any   	=		testing_file
              UpperCamelCase    :	Dict   	=		path






       def  _lowercase   (     self						):




              """simple docstring"""




              warnings.warn(
                  '''The command `transformers-cli add-new-model` is deprecated and will be removed in v5 of Transformers. '''
                  '''It is not actively maintained anymore, so might give a result that won\'t pass all tests and quality '''
                  '''checks, you should use `transformers-cli add-new-model-like` instead.'''						)
              if not _has_cookiecutter:
                     raise ImportError(
                         '''Model creation dependencies are required to use the `add_new_model` command. Install them by running '''
                         '''the following at the root of your `transformers` clone:\n\n\t$ pip install -e .[modelcreation]\n'''						)
              # Ensure that there is no other `cookiecutter-template-xxx` directory in the current working directory
              UpperCamelCase    :	List[str]   	=		[directory for directory in os.listdir() if '''cookiecutter-template-''' == directory[:22]]
              if len(__SCREAMING_SNAKE_CASE						) > 0:
                     raise ValueError(
                         '''Several directories starting with `cookiecutter-template-` in current working directory. '''
                         '''Please clean your directory by removing all folders starting with `cookiecutter-template-` or '''
                         '''change your working directory.'''						)

              UpperCamelCase    :	Dict   	=		(
                  Path(__SCREAMING_SNAKE_CASE						).parent.parent.parent.parent if self._path is None else Path(self._path						).parent.parent
              )
              UpperCamelCase    :	List[Any]   	=		path_to_transformer_root / '''templates''' / '''adding_a_new_model'''

              # Execute cookiecutter
              if not self._testing:
                     cookiecutter(str(__SCREAMING_SNAKE_CASE						)						)
              else:
                     with open(self._testing_file ,					'''r'''						) as configuration_file:
                            UpperCamelCase    :	Tuple   	=		json.load(__SCREAMING_SNAKE_CASE						)

                     cookiecutter(
                         str(path_to_cookiecutter if self._path is None else self._path						) ,					no_input=__SCREAMING_SNAKE_CASE ,					extra_context=__SCREAMING_SNAKE_CASE ,					)

              UpperCamelCase    :	Dict   	=		[directory for directory in os.listdir() if '''cookiecutter-template-''' in directory[:22]][0]

              # Retrieve configuration
              with open(directory + '''/configuration.json''' ,					'''r'''						) as configuration_file:
                     UpperCamelCase    :	Tuple   	=		json.load(__SCREAMING_SNAKE_CASE						)

              UpperCamelCase    :	Dict   	=		configuration['''lowercase_modelname''']
              UpperCamelCase    :	int   	=		configuration['''generate_tensorflow_pytorch_and_flax''']
              os.remove(f"""{directory}/configuration.json"""						)

              UpperCamelCase    :	str   	=		'''PyTorch''' in generate_tensorflow_pytorch_and_flax
              UpperCamelCase    :	Any   	=		'''TensorFlow''' in generate_tensorflow_pytorch_and_flax
              UpperCamelCase    :	Union[str, Any]   	=		'''Flax''' in generate_tensorflow_pytorch_and_flax

              UpperCamelCase    :	Optional[Any]   	=		f"""{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}"""
              os.makedirs(__SCREAMING_SNAKE_CASE ,					exist_ok=__SCREAMING_SNAKE_CASE						)
              os.makedirs(f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}""" ,					exist_ok=__SCREAMING_SNAKE_CASE						)

              # Tests require submodules as they have parent imports
              with open(f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/__init__.py""" ,					'''w'''						):
                     pass

              shutil.move(
                  f"""{directory}/__init__.py""" ,					f"""{model_dir}/__init__.py""" ,					)
              shutil.move(
                  f"""{directory}/configuration_{lowercase_model_name}.py""" ,					f"""{model_dir}/configuration_{lowercase_model_name}.py""" ,					)

              def remove_copy_lines(__SCREAMING_SNAKE_CASE						):
                     with open(__SCREAMING_SNAKE_CASE ,					'''r'''						) as f:
                            UpperCamelCase    :	Any   	=		f.readlines()
                     with open(__SCREAMING_SNAKE_CASE ,					'''w'''						) as f:
                            for line in lines:
                                   if "# Copied from transformers." not in line:
                                          f.write(__SCREAMING_SNAKE_CASE						)

              if output_pytorch:
                     if not self._testing:
                            remove_copy_lines(f"""{directory}/modeling_{lowercase_model_name}.py"""						)

                     shutil.move(
                         f"""{directory}/modeling_{lowercase_model_name}.py""" ,					f"""{model_dir}/modeling_{lowercase_model_name}.py""" ,					)

                     shutil.move(
                         f"""{directory}/test_modeling_{lowercase_model_name}.py""" ,					f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_{lowercase_model_name}.py""" ,					)
              else:
                     os.remove(f"""{directory}/modeling_{lowercase_model_name}.py"""						)
                     os.remove(f"""{directory}/test_modeling_{lowercase_model_name}.py"""						)

              if output_tensorflow:
                     if not self._testing:
                            remove_copy_lines(f"""{directory}/modeling_tf_{lowercase_model_name}.py"""						)

                     shutil.move(
                         f"""{directory}/modeling_tf_{lowercase_model_name}.py""" ,					f"""{model_dir}/modeling_tf_{lowercase_model_name}.py""" ,					)

                     shutil.move(
                         f"""{directory}/test_modeling_tf_{lowercase_model_name}.py""" ,					f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_tf_{lowercase_model_name}.py""" ,					)
              else:
                     os.remove(f"""{directory}/modeling_tf_{lowercase_model_name}.py"""						)
                     os.remove(f"""{directory}/test_modeling_tf_{lowercase_model_name}.py"""						)

              if output_flax:
                     if not self._testing:
                            remove_copy_lines(f"""{directory}/modeling_flax_{lowercase_model_name}.py"""						)

                     shutil.move(
                         f"""{directory}/modeling_flax_{lowercase_model_name}.py""" ,					f"""{model_dir}/modeling_flax_{lowercase_model_name}.py""" ,					)

                     shutil.move(
                         f"""{directory}/test_modeling_flax_{lowercase_model_name}.py""" ,					f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_flax_{lowercase_model_name}.py""" ,					)
              else:
                     os.remove(f"""{directory}/modeling_flax_{lowercase_model_name}.py"""						)
                     os.remove(f"""{directory}/test_modeling_flax_{lowercase_model_name}.py"""						)

              shutil.move(
                  f"""{directory}/{lowercase_model_name}.md""" ,					f"""{path_to_transformer_root}/docs/source/en/model_doc/{lowercase_model_name}.md""" ,					)

              shutil.move(
                  f"""{directory}/tokenization_{lowercase_model_name}.py""" ,					f"""{model_dir}/tokenization_{lowercase_model_name}.py""" ,					)

              shutil.move(
                  f"""{directory}/tokenization_fast_{lowercase_model_name}.py""" ,					f"""{model_dir}/tokenization_{lowercase_model_name}_fast.py""" ,					)

              from os import fdopen, remove
              from shutil import copymode, move
              from tempfile import mkstemp

              def replace(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						):
                     # Create temp file
                     UpperCamelCase	, UpperCamelCase    :	Optional[Any]   	=		mkstemp()
                     UpperCamelCase    :	Tuple   	=		False
                     with fdopen(__SCREAMING_SNAKE_CASE ,					'''w'''						) as new_file:
                            with open(__SCREAMING_SNAKE_CASE						) as old_file:
                                   for line in old_file:
                                          new_file.write(__SCREAMING_SNAKE_CASE						)
                                          if line_to_copy_below in line:
                                                 UpperCamelCase    :	Optional[int]   	=		True
                                                 for line_to_copy in lines_to_copy:
                                                        new_file.write(__SCREAMING_SNAKE_CASE						)

                     if not line_found:
                            raise ValueError(f"""Line {line_to_copy_below} was not found in file."""						)

                     # Copy the file permissions from the old file to the new file
                     copymode(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						)
                     # Remove original file
                     remove(__SCREAMING_SNAKE_CASE						)
                     # Move new file
                     move(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						)

              def skip_units(__SCREAMING_SNAKE_CASE						):
                     return (
                         ("generating PyTorch" in line and not output_pytorch)
                         or ("generating TensorFlow" in line and not output_tensorflow)
                         or ("generating Flax" in line and not output_flax)
                     )

              def replace_in_files(__SCREAMING_SNAKE_CASE						):
                     with open(__SCREAMING_SNAKE_CASE						) as datafile:
                            UpperCamelCase    :	int   	=		[]
                            UpperCamelCase    :	Dict   	=		False
                            UpperCamelCase    :	List[Any]   	=		False
                            for line in datafile:
                                   if "# To replace in: " in line and "##" not in line:
                                          UpperCamelCase    :	Dict   	=		line.split('''"'''						)[1]
                                          UpperCamelCase    :	int   	=		skip_units(__SCREAMING_SNAKE_CASE						)
                                   elif "# Below: " in line and "##" not in line:
                                          UpperCamelCase    :	Dict   	=		line.split('''"'''						)[1]
                                          UpperCamelCase    :	List[str]   	=		skip_units(__SCREAMING_SNAKE_CASE						)
                                   elif "# End." in line and "##" not in line:
                                          if not skip_file and not skip_snippet:
                                                 replace(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						)

                                          UpperCamelCase    :	Dict   	=		[]
                                   elif "# Replace with" in line and "##" not in line:
                                          UpperCamelCase    :	Tuple   	=		[]
                                   elif "##" not in line:
                                          lines_to_copy.append(__SCREAMING_SNAKE_CASE						)

                     remove(__SCREAMING_SNAKE_CASE						)

              replace_in_files(f"""{directory}/to_replace_{lowercase_model_name}.py"""						)
              os.rmdir(__SCREAMING_SNAKE_CASE						)

