


"""simple docstring"""






import argparse
import re
from pathlib import Path

import requests
import torch
from PIL import Image
from torchvision.transforms import CenterCrop, Compose, Normalize, Resize, ToTensor

from transformers import (
    EfficientFormerConfig,
    EfficientFormerForImageClassificationWithTeacher,
    EfficientFormerImageProcessor,
)
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling





def 				A_       ( snake_case__       ,					snake_case__		)					->  Union[str, Any]:
			_UpperCamelCase					:Any					     =	old_name

			if "patch_embed" in old_name:
						_UpperCamelCase					:Optional[int]					     =	old_name.split('''.'''		)

						if layer == "0":
									_UpperCamelCase					:str					     =	old_name.replace('''0'''       ,					'''convolution1'''		)
						elif layer == "1":
									_UpperCamelCase					:Optional[int]					     =	old_name.replace('''1'''       ,					'''batchnorm_before'''		)
						elif layer == "3":
									_UpperCamelCase					:Dict					     =	old_name.replace('''3'''       ,					'''convolution2'''		)
						else:
									_UpperCamelCase					:Optional[Any]					     =	old_name.replace('''4'''       ,					'''batchnorm_after'''		)

			if "network" in old_name and re.search(R'''\d\.\d'''       ,					snake_case__		):
						_UpperCamelCase					:List[str]					     =	R"\b\d{2}\b"
						if bool(re.search(snake_case__       ,					snake_case__		)		):
									_UpperCamelCase					:Dict					     =	re.search(R'''\d\.\d\d.'''       ,					snake_case__		).group()
						else:
									_UpperCamelCase					:Optional[int]					     =	re.search(R'''\d\.\d.'''       ,					snake_case__		).group()
						if int(match[0]		) < 6:
									_UpperCamelCase					:Optional[int]					     =	old_name.replace(snake_case__       ,					''''''		)
									_UpperCamelCase					:Optional[int]					     =	trimmed_name.replace('''network'''       ,					match[0] + '''.meta4D_layers.blocks.''' + match[2:-1]		)
									_UpperCamelCase					:Dict					     =	"intermediate_stages." + trimmed_name
						else:
									_UpperCamelCase					:List[Any]					     =	old_name.replace(snake_case__       ,					''''''		)
									if int(match[2]		) < num_meta4D_last_stage:
												_UpperCamelCase					:List[str]					     =	trimmed_name.replace('''network'''       ,					'''meta4D_layers.blocks.''' + match[2]		)
									else:
												_UpperCamelCase					:Any					     =	str(int(match[2]		) - num_meta4D_last_stage		)
												_UpperCamelCase					:int					     =	trimmed_name.replace('''network'''       ,					'''meta3D_layers.blocks.''' + layer_index		)
												if "norm1" in old_name:
															_UpperCamelCase					:List[str]					     =	trimmed_name.replace('''norm1'''       ,					'''layernorm1'''		)
												elif "norm2" in old_name:
															_UpperCamelCase					:Tuple					     =	trimmed_name.replace('''norm2'''       ,					'''layernorm2'''		)
												elif "fc1" in old_name:
															_UpperCamelCase					:List[str]					     =	trimmed_name.replace('''fc1'''       ,					'''linear_in'''		)
												elif "fc2" in old_name:
															_UpperCamelCase					:Tuple					     =	trimmed_name.replace('''fc2'''       ,					'''linear_out'''		)

									_UpperCamelCase					:str					     =	"last_stage." + trimmed_name

			elif "network" in old_name and re.search(R'''.\d.'''       ,					snake_case__		):
						_UpperCamelCase					:int					     =	old_name.replace('''network'''       ,					'''intermediate_stages'''		)

			if "fc" in new_name:
						_UpperCamelCase					:List[Any]					     =	new_name.replace('''fc'''       ,					'''convolution'''		)
			elif ("norm1" in new_name) and ("layernorm1" not in new_name):
						_UpperCamelCase					:str					     =	new_name.replace('''norm1'''       ,					'''batchnorm_before'''		)
			elif ("norm2" in new_name) and ("layernorm2" not in new_name):
						_UpperCamelCase					:Union[str, Any]					     =	new_name.replace('''norm2'''       ,					'''batchnorm_after'''		)
			if "proj" in new_name:
						_UpperCamelCase					:Tuple					     =	new_name.replace('''proj'''       ,					'''projection'''		)
			if "dist_head" in new_name:
						_UpperCamelCase					:Dict					     =	new_name.replace('''dist_head'''       ,					'''distillation_classifier'''		)
			elif "head" in new_name:
						_UpperCamelCase					:List[str]					     =	new_name.replace('''head'''       ,					'''classifier'''		)
			elif "patch_embed" in new_name:
						_UpperCamelCase					:Optional[Any]					     =	"efficientformer." + new_name
			elif new_name == "norm.weight" or new_name == "norm.bias":
						_UpperCamelCase					:Tuple					     =	new_name.replace('''norm'''       ,					'''layernorm'''		)
						_UpperCamelCase					:List[str]					     =	"efficientformer." + new_name
			else:
						_UpperCamelCase					:List[str]					     =	"efficientformer.encoder." + new_name

			return new_name





def 				A_       ( snake_case__       ,					snake_case__		)					->  Dict:





			for key in checkpoint.copy().keys():
						_UpperCamelCase					:Optional[int]					     =	checkpoint.pop(snake_case__		)
						_UpperCamelCase					:Dict					     =	val

			return checkpoint





def 				A_       ( )					->  Any:
			_UpperCamelCase					:Dict					     =	"http://images.cocodataset.org/val2017/000000039769.jpg"
			_UpperCamelCase					:Tuple					     =	Image.open(requests.get(snake_case__       ,					stream=snake_case__		).raw		)

			return image





def 				A_       ( snake_case__       ,					snake_case__       ,					snake_case__       ,					snake_case__		)					->  Optional[int]:
			_UpperCamelCase					:Any					     =	torch.load(snake_case__       ,					map_location='''cpu'''		)["model"]
			_UpperCamelCase					:Optional[int]					     =	EfficientFormerConfig.from_json_file(snake_case__		)
			_UpperCamelCase					:Union[str, Any]					     =	EfficientFormerForImageClassificationWithTeacher(snake_case__		)
			_UpperCamelCase					:str					     =	"_".join(checkpoint_path.split('''/'''		)[-1].split('''.'''		)[0].split('''_'''		)[:-1]		)

			_UpperCamelCase					:Union[str, Any]					     =	config.depths[-1] - config.num_metaad_blocks + 1
			_UpperCamelCase					:Any					     =	convert_torch_checkpoint(snake_case__       ,					snake_case__		)

			model.load_state_dict(snake_case__		)
			model.eval()

			_UpperCamelCase					:Any					     =	{
			    "bilinear": PILImageResampling.BILINEAR,
			    "bicubic": PILImageResampling.BICUBIC,
			    "nearest": PILImageResampling.NEAREST,
			}

			# prepare image
			_UpperCamelCase					:List[str]					     =	prepare_img()
			_UpperCamelCase					:str					     =	2_56
			_UpperCamelCase					:List[str]					     =	2_24
			_UpperCamelCase					:Tuple					     =	EfficientFormerImageProcessor(
			    size={'''shortest_edge''': image_size}       ,					crop_size={'''height''': crop_size, '''width''': crop_size}       ,					resample=pillow_resamplings['''bicubic''']       ,					)
			_UpperCamelCase					:List[str]					     =	processor(images=snake_case__       ,					return_tensors='''pt'''		).pixel_values

			# original processing pipeline
			_UpperCamelCase					:str					     =	Compose(
			    [
			        Resize(snake_case__       ,					interpolation=pillow_resamplings['''bicubic''']		),
			        CenterCrop(snake_case__		),
			        ToTensor(),
			        Normalize(snake_case__       ,					snake_case__		),
			    ]		)
			_UpperCamelCase					:str					     =	image_transforms(snake_case__		).unsqueeze(0		)

			assert torch.allclose(snake_case__       ,					snake_case__		)

			_UpperCamelCase					:List[str]					     =	model(snake_case__		)
			_UpperCamelCase					:str					     =	outputs.logits

			_UpperCamelCase					:Optional[int]					     =	(1, 10_00)

			if "l1" in model_name:
						_UpperCamelCase					:Dict					     =	torch.Tensor(
						    [-0.13_12, 0.43_53, -1.04_99, -0.51_24, 0.41_83, -0.67_93, -1.37_77, -0.08_93, -0.73_58, -2.43_28]		)
						assert torch.allclose(logits[0, :10]       ,					snake_case__       ,					atol=1E-3		)
						assert logits.shape == expected_shape
			elif "l3" in model_name:
						_UpperCamelCase					:int					     =	torch.Tensor(
						    [-1.31_50, -1.54_56, -1.25_56, -0.84_96, -0.71_27, -0.78_97, -0.97_28, -0.30_52, 0.37_51, -0.31_27]		)
						assert torch.allclose(logits[0, :10]       ,					snake_case__       ,					atol=1E-3		)
						assert logits.shape == expected_shape
			elif "l7" in model_name:
						_UpperCamelCase					:str					     =	torch.Tensor(
						    [-1.02_83, -1.41_31, -0.56_44, -1.31_15, -0.57_85, -1.20_49, -0.75_28, 0.19_92, -0.38_22, -0.08_78]		)
						assert logits.shape == expected_shape
			else:
						raise ValueError(
						    f"Unknown model checkpoint: {checkpoint_path}. Supported version of efficientformer are l1, l3 and l7"		)

			# Save Checkpoints
			Path(snake_case__		).mkdir(exist_ok=snake_case__		)
			model.save_pretrained(snake_case__		)
			print(f"Checkpoint successfuly converted. Model saved at {pytorch_dump_path}"		)
			processor.save_pretrained(snake_case__		)
			print(f"Processor successfuly saved at {pytorch_dump_path}"		)

			if push_to_hub:
						print('''Pushing model to the hub...'''		)

						model.push_to_hub(
						    repo_id=f"Bearnardd/{pytorch_dump_path}"       ,					commit_message='''Add model'''       ,					use_temp_dir=snake_case__       ,					)
						processor.push_to_hub(
						    repo_id=f"Bearnardd/{pytorch_dump_path}"       ,					commit_message='''Add image processor'''       ,					use_temp_dir=snake_case__       ,					)


if __name__ == "__main__":
					UpperCamelCase__				:Union[str, Any]			   =	argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--pytorch_model_path""",
					    default=None,
					    type=str,
					    required=True,
					    help="""Path to EfficientFormer pytorch checkpoint.""",
					)
					parser.add_argument(
					    """--config_file""",
					    default=None,
					    type=str,
					    required=True,
					    help="""The json file for EfficientFormer model config.""",
					)
					parser.add_argument(
					    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
					)

					parser.add_argument("""--push_to_hub""", action="""store_true""", help="""Push model and image processor to the hub""")
					parser.add_argument(
					    """--no-push_to_hub""",
					    dest="""push_to_hub""",
					    action="""store_false""",
					    help="""Do not push model and image processor to the hub""",
					)
					parser.set_defaults(push_to_hub=True)

					UpperCamelCase__				:int			   =	parser.parse_args()
					convert_efficientformer_checkpoint(
					    checkpoint_path=args.pytorch_model_path,
					    efficientformer_config_file=args.config_file,
					    pytorch_dump_path=args.pytorch_dump_path,
					    push_to_hub=args.push_to_hub,
					)





"""simple docstring"""



import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
  from test_module.custom_tokenization_fast import CustomTokenizerFast







class _lowerCAmelCase							( unittest.TestCase      ):







   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




       snake_case       : List[str]    =       mock.Mock()
       snake_case       : Any    =       500
       snake_case       : int    =       {}
       snake_case       : int    =       HTTPError
       snake_case       : Dict    =       {}

       # Download this model to make sure it's in the cache.
       snake_case       : Dict    =       BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"		)

       # Under the mock environment we get a 500 error when trying to reach the tokenizer.
       with mock.patch("requests.Session.request"		,      return_value=UpperCamelCase__		) as mock_head:
           snake_case       : str    =       BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"		)
           # This check we did call the fake head request
           mock_head.assert_called()







   @require_tokenizers
   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




       snake_case       : Union[str, Any]    =       mock.Mock()
       snake_case       : int    =       500
       snake_case       : Optional[int]    =       {}
       snake_case       : int    =       HTTPError
       snake_case       : int    =       {}

       # Download this model to make sure it's in the cache.
       snake_case       : Any    =       GPTaTokenizerFast.from_pretrained("gpt2"		)

       # Under the mock environment we get a 500 error when trying to reach the tokenizer.
       with mock.patch("requests.Session.request"		,      return_value=UpperCamelCase__		) as mock_head:
           snake_case       : Tuple    =       GPTaTokenizerFast.from_pretrained("gpt2"		)
           # This check we did call the fake head request
           mock_head.assert_called()







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

       '''simple docstring'''




       try:
           snake_case       : Tuple    =       tempfile.mktemp()
           with open(UpperCamelCase__		,      "wb"		) as f:
               http_get("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"		,      UpperCamelCase__		)

           snake_case       : List[str]    =       AlbertTokenizer.from_pretrained(UpperCamelCase__		)
       finally:
           os.remove(UpperCamelCase__		)

       # Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
       # the current folder and have the right name.
       if os.path.isfile("tokenizer.json"		):
           # We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
           return
       try:
           with open("tokenizer.json"		,      "wb"		) as f:
               http_get("https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json"		,      UpperCamelCase__		)
           snake_case       : Dict    =       AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
           # The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
           self.assertEqual(tokenizer.vocab_size		,      1000		)
           # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

       finally:
           os.remove("tokenizer.json"		)







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

       '''simple docstring'''




       snake_case       : int    =       AlbertTokenizer.from_pretrained("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"		)







@is_staging_test
class _lowerCAmelCase							( unittest.TestCase      ):
   __UpperCAmelCase					:			Dict				    =    ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']







   @classmethod
   def 					lowerCamelCase						(      cls		)      ->						Optional[int]:

       '''simple docstring'''




       snake_case       : List[str]    =       TOKEN
       HfFolder.save_token(UpperCamelCase__		)







   @classmethod
   def 					lowerCamelCase						(      cls		)      ->						Union[str, Any]:

       '''simple docstring'''




       try:
           delete_repo(token=cls._token		,      repo_id="test-tokenizer"		)
       except HTTPError:
           pass

       try:
           delete_repo(token=cls._token		,      repo_id="valid_org/test-tokenizer-org"		)
       except HTTPError:
           pass

       try:
           delete_repo(token=cls._token		,      repo_id="test-dynamic-tokenizer"		)
       except HTTPError:
           pass







   def 					lowerCamelCase						(      self		)      ->						Dict:

       '''simple docstring'''




       with tempfile.TemporaryDirectory() as tmp_dir:
           snake_case       : Any    =       os.path.join(UpperCamelCase__		,      "vocab.txt"		)
           with open(UpperCamelCase__		,      "w"		,      encoding="utf-8"		) as vocab_writer:
               vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)
           snake_case       : List[str]    =       BertTokenizer(UpperCamelCase__		)

       tokenizer.push_to_hub("test-tokenizer"		,      use_auth_token=self._token		)
       snake_case       : Dict    =       BertTokenizer.from_pretrained(F'{USER}/test-tokenizer'		)
       self.assertDictEqual(new_tokenizer.vocab		,      tokenizer.vocab		)

       # Reset repo
       delete_repo(token=self._token		,      repo_id="test-tokenizer"		)

       # Push to hub via save_pretrained
       with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(UpperCamelCase__		,      repo_id="test-tokenizer"		,      push_to_hub=UpperCamelCase__		,      use_auth_token=self._token		)

       snake_case       : Dict    =       BertTokenizer.from_pretrained(F'{USER}/test-tokenizer'		)
       self.assertDictEqual(new_tokenizer.vocab		,      tokenizer.vocab		)







   def 					lowerCamelCase						(      self		)      ->						Any:

       '''simple docstring'''




       with tempfile.TemporaryDirectory() as tmp_dir:
           snake_case       : Dict    =       os.path.join(UpperCamelCase__		,      "vocab.txt"		)
           with open(UpperCamelCase__		,      "w"		,      encoding="utf-8"		) as vocab_writer:
               vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)
           snake_case       : Optional[int]    =       BertTokenizer(UpperCamelCase__		)

       tokenizer.push_to_hub("valid_org/test-tokenizer-org"		,      use_auth_token=self._token		)
       snake_case       : Dict    =       BertTokenizer.from_pretrained("valid_org/test-tokenizer-org"		)
       self.assertDictEqual(new_tokenizer.vocab		,      tokenizer.vocab		)

       # Reset repo
       delete_repo(token=self._token		,      repo_id="valid_org/test-tokenizer-org"		)

       # Push to hub via save_pretrained
       with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(
               UpperCamelCase__		,      repo_id="valid_org/test-tokenizer-org"		,      push_to_hub=UpperCamelCase__		,      use_auth_token=self._token		)

       snake_case       : Optional[int]    =       BertTokenizer.from_pretrained("valid_org/test-tokenizer-org"		)
       self.assertDictEqual(new_tokenizer.vocab		,      tokenizer.vocab		)







   @require_tokenizers
   def 					lowerCamelCase						(      self		)      ->						Union[str, Any]:

       '''simple docstring'''




       CustomTokenizer.register_for_auto_class()
       with tempfile.TemporaryDirectory() as tmp_dir:
           snake_case       : Tuple    =       os.path.join(UpperCamelCase__		,      "vocab.txt"		)
           with open(UpperCamelCase__		,      "w"		,      encoding="utf-8"		) as vocab_writer:
               vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)
           snake_case       : Any    =       CustomTokenizer(UpperCamelCase__		)

       # No fast custom tokenizer
       tokenizer.push_to_hub("test-dynamic-tokenizer"		,      use_auth_token=self._token		)

       snake_case       : Union[str, Any]    =       AutoTokenizer.from_pretrained(F'{USER}/test-dynamic-tokenizer'		,      trust_remote_code=UpperCamelCase__		)
       # Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
       self.assertEqual(tokenizer.__class__.__name__		,      "CustomTokenizer"		)

       # Fast and slow custom tokenizer
       CustomTokenizerFast.register_for_auto_class()
       with tempfile.TemporaryDirectory() as tmp_dir:
           snake_case       : int    =       os.path.join(UpperCamelCase__		,      "vocab.txt"		)
           with open(UpperCamelCase__		,      "w"		,      encoding="utf-8"		) as vocab_writer:
               vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]		)		)

           snake_case       : Optional[Any]    =       BertTokenizerFast.from_pretrained(UpperCamelCase__		)
           bert_tokenizer.save_pretrained(UpperCamelCase__		)
           snake_case       : List[Any]    =       CustomTokenizerFast.from_pretrained(UpperCamelCase__		)

       tokenizer.push_to_hub("test-dynamic-tokenizer"		,      use_auth_token=self._token		)

       snake_case       : Union[str, Any]    =       AutoTokenizer.from_pretrained(F'{USER}/test-dynamic-tokenizer'		,      trust_remote_code=UpperCamelCase__		)
       # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
       self.assertEqual(tokenizer.__class__.__name__		,      "CustomTokenizerFast"		)
       snake_case       : Optional[Any]    =       AutoTokenizer.from_pretrained(
           F'{USER}/test-dynamic-tokenizer'		,      use_fast=UpperCamelCase__		,      trust_remote_code=UpperCamelCase__		)
       # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
       self.assertEqual(tokenizer.__class__.__name__		,      "CustomTokenizer"		)







class _lowerCAmelCase							( unittest.TestCase      ):







   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




       snake_case       : Any    =       Trie()
       trie.add("Hello 友達"		)
       self.assertEqual(trie.data		,      {"H": {"e": {"l": {"l": {"o": {" ": {"友": {"達": {"": 1}}}}}}}}}		)
       trie.add("Hello"		)
       trie.data
       self.assertEqual(trie.data		,      {"H": {"e": {"l": {"l": {"o": {"": 1, " ": {"友": {"達": {"": 1}}}}}}}}}		)







   def 					lowerCamelCase						(      self		)      ->						Any:

       '''simple docstring'''




       snake_case       : Tuple    =       Trie()
       self.assertEqual(trie.split("[CLS] This is a extra_id_100"		)		,      ["[CLS] This is a extra_id_100"]		)
       trie.add("[CLS]"		)
       trie.add("extra_id_1"		)
       trie.add("extra_id_100"		)
       self.assertEqual(trie.split("[CLS] This is a extra_id_100"		)		,      ["[CLS]", " This is a ", "extra_id_100"]		)







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

       '''simple docstring'''




       snake_case       : str    =       Trie()
       trie.add("A"		)
       self.assertEqual(trie.split("ABC"		)		,      ["A", "BC"]		)
       self.assertEqual(trie.split("BCA"		)		,      ["BC", "A"]		)







   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




       snake_case       : Union[str, Any]    =       Trie()
       trie.add("TOKEN]"		)
       trie.add("[SPECIAL_TOKEN]"		)
       self.assertEqual(trie.split("This is something [SPECIAL_TOKEN]"		)		,      ["This is something ", "[SPECIAL_TOKEN]"]		)







   def 					lowerCamelCase						(      self		)      ->						Tuple:

       '''simple docstring'''




       snake_case       : Optional[int]    =       Trie()
       trie.add("A"		)
       trie.add("P"		)
       trie.add("[SPECIAL_TOKEN]"		)
       self.assertEqual(trie.split("This is something [SPECIAL_TOKEN]"		)		,      ["This is something ", "[SPECIAL_TOKEN]"]		)







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

       '''simple docstring'''




       snake_case       : List[Any]    =       Trie()
       trie.add("AB"		)
       trie.add("B"		)
       trie.add("C"		)
       self.assertEqual(trie.split("ABC"		)		,      ["AB", "C"]		)







   def 					lowerCamelCase						(      self		)      ->						Dict:

       '''simple docstring'''




       snake_case       : str    =       Trie()
       trie.add("ABC"		)
       trie.add("B"		)
       trie.add("CD"		)
       self.assertEqual(trie.split("ABCD"		)		,      ["ABC", "D"]		)







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

       '''simple docstring'''




       snake_case       : Optional[int]    =       Trie()
       snake_case       : Union[str, Any]    =       trie.cut_text("ABC"		,      [0, 0, 2, 1, 2, 3]		)
       self.assertEqual(UpperCamelCase__		,      ["AB", "C"]		)





