





'''simple docstring'''

from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
    import PIL


a   	=    logging.get_logger(__name__)







class __a			( _snake_case      ):
   __UpperCamelCase :			List[Any]						   =						['pixel_values']





   def __init__(       self					:      Dict					,lowerCamelCase					:      bool = True					,lowerCamelCase					:      Dict[str, int] = None					,lowerCamelCase					:      int = 0.9					,lowerCamelCase					:      PILImageResampling = PILImageResampling.BICUBIC					,lowerCamelCase					:      bool = True					,lowerCamelCase					:      Dict[str, int] = None					,lowerCamelCase					:      Union[int, float] = 1 / 255					,lowerCamelCase					:      bool = True					,lowerCamelCase					:      bool = True					,lowerCamelCase					:      Optional[Union[float, List[float]]] = None					,lowerCamelCase					:      Optional[Union[float, List[float]]] = None					,**lowerCamelCase					:      Union[str, Any]					,):

      '''simple docstring'''

      super().__init__(**lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							size if size is not None else {"""shortest_edge""": 224}
      __SCREAMING_SNAKE_CASE   				=							get_size_dict(lowerCamelCase					,default_to_square=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
      __SCREAMING_SNAKE_CASE   				=							get_size_dict(lowerCamelCase					,param_name="""crop_size"""     )

      __SCREAMING_SNAKE_CASE   				=							do_resize
      __SCREAMING_SNAKE_CASE   				=							size
      __SCREAMING_SNAKE_CASE   				=							crop_pct
      __SCREAMING_SNAKE_CASE   				=							resample
      __SCREAMING_SNAKE_CASE   				=							do_center_crop
      __SCREAMING_SNAKE_CASE   				=							crop_size
      __SCREAMING_SNAKE_CASE   				=							do_rescale
      __SCREAMING_SNAKE_CASE   				=							rescale_factor
      __SCREAMING_SNAKE_CASE   				=							do_normalize
      __SCREAMING_SNAKE_CASE   				=							image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
      __SCREAMING_SNAKE_CASE   				=							image_std if image_std is not None else IMAGENET_DEFAULT_STD





   def   UpperCAmelCase__  (       self					:      Optional[int]					,lowerCamelCase					:      np.ndarray					,lowerCamelCase					:      Dict[str, int]					,lowerCamelCase					:      Optional[float] = None					,lowerCamelCase					:      PILImageResampling = PILImageResampling.BICUBIC					,lowerCamelCase					:      Optional[Union[str, ChannelDimension]] = None					,**lowerCamelCase					:      Any					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							get_size_dict(lowerCamelCase					,default_to_square=lowerCamelCase     )
      if "shortest_edge" not in size and ("height" not in size or "width" not in size):
         raise ValueError(f"""size must contain 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"""     )
      if crop_pct is not None:
         if "shortest_edge" in size:
            __SCREAMING_SNAKE_CASE   				=							int(size["""shortest_edge"""] / crop_pct     )
         elif "height" in size and "width" in size:
            if size["height"] == size["width"]:
               __SCREAMING_SNAKE_CASE   				=							int(size["""height"""] / crop_pct     )
            else:
               __SCREAMING_SNAKE_CASE   				=							(int(size["""height"""] / crop_pct     ), int(size["""width"""] / crop_pct     ))
         else:
            raise ValueError("""Invalid size for resize: {}""".format(lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							get_resize_output_image_size(lowerCamelCase					,size=lowerCamelCase					,default_to_square=lowerCamelCase     )
      else:
         if "shortest_edge" in size:
            __SCREAMING_SNAKE_CASE   				=							get_resize_output_image_size(lowerCamelCase					,size=size["""shortest_edge"""]					,default_to_square=lowerCamelCase     )
         elif "height" in size and "width" in size:
            __SCREAMING_SNAKE_CASE   				=							(size["""height"""], size["""width"""])
         else:
            raise ValueError("""Invalid size for resize: {}""".format(lowerCamelCase     )     )

      return resize(lowerCamelCase					,size=lowerCamelCase					,resample=lowerCamelCase					,data_format=lowerCamelCase					,**lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Optional[int]					,lowerCamelCase					:      np.ndarray					,lowerCamelCase					:      Dict[str, int]					,lowerCamelCase					:      Optional[Union[str, ChannelDimension]] = None					,**lowerCamelCase					:      int					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							get_size_dict(lowerCamelCase     )
      if "height" not in size or "width" not in size:
         raise ValueError(f"""size must contain 'height' and 'width' as keys. Got {size.keys()}"""     )
      return center_crop(lowerCamelCase					,size=(size["""height"""], size["""width"""])					,data_format=lowerCamelCase					,**lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Any					,lowerCamelCase					:      np.ndarray					,lowerCamelCase					:      Union[int, float]					,lowerCamelCase					:      Optional[Union[str, ChannelDimension]] = None					,**lowerCamelCase					:      List[str]					,):

      '''simple docstring'''

      return rescale(lowerCamelCase					,scale=lowerCamelCase					,data_format=lowerCamelCase					,**lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Any					,lowerCamelCase					:      np.ndarray					,lowerCamelCase					:      Union[float, List[float]]					,lowerCamelCase					:      Union[float, List[float]]					,lowerCamelCase					:      Optional[Union[str, ChannelDimension]] = None					,**lowerCamelCase					:      int					,):

      '''simple docstring'''

      return normalize(lowerCamelCase					,mean=lowerCamelCase					,std=lowerCamelCase					,data_format=lowerCamelCase					,**lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Optional[Any]					,lowerCamelCase					:      ImageInput					,lowerCamelCase					:      bool = None					,lowerCamelCase					:      Dict[str, int] = None					,lowerCamelCase					:      int = None					,lowerCamelCase					:      PILImageResampling = None					,lowerCamelCase					:      bool = None					,lowerCamelCase					:      Dict[str, int] = None					,lowerCamelCase					:      bool = None					,lowerCamelCase					:      float = None					,lowerCamelCase					:      bool = None					,lowerCamelCase					:      Optional[Union[float, List[float]]] = None					,lowerCamelCase					:      Optional[Union[float, List[float]]] = None					,lowerCamelCase					:      Optional[Union[str, TensorType]] = None					,lowerCamelCase					:      ChannelDimension = ChannelDimension.FIRST					,**lowerCamelCase					:      Optional[int]					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							do_resize if do_resize is not None else self.do_resize
      __SCREAMING_SNAKE_CASE   				=							crop_pct if crop_pct is not None else self.crop_pct
      __SCREAMING_SNAKE_CASE   				=							resample if resample is not None else self.resample
      __SCREAMING_SNAKE_CASE   				=							do_center_crop if do_center_crop is not None else self.do_center_crop
      __SCREAMING_SNAKE_CASE   				=							do_rescale if do_rescale is not None else self.do_rescale
      __SCREAMING_SNAKE_CASE   				=							rescale_factor if rescale_factor is not None else self.rescale_factor
      __SCREAMING_SNAKE_CASE   				=							do_normalize if do_normalize is not None else self.do_normalize
      __SCREAMING_SNAKE_CASE   				=							image_mean if image_mean is not None else self.image_mean
      __SCREAMING_SNAKE_CASE   				=							image_std if image_std is not None else self.image_std

      __SCREAMING_SNAKE_CASE   				=							size if size is not None else self.size
      __SCREAMING_SNAKE_CASE   				=							get_size_dict(lowerCamelCase					,default_to_square=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							crop_size if crop_size is not None else self.crop_size
      __SCREAMING_SNAKE_CASE   				=							get_size_dict(lowerCamelCase					,param_name="""crop_size"""     )

      __SCREAMING_SNAKE_CASE   				=							make_list_of_images(lowerCamelCase     )

      if not valid_images(lowerCamelCase     ):
         raise ValueError(
             """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
             """torch.Tensor, tf.Tensor or jax.ndarray."""     )

      if do_resize and size is None or resample is None:
         raise ValueError("""Size and resample must be specified if do_resize is True."""     )

      if do_center_crop and crop_pct is None:
         raise ValueError("""Crop_pct must be specified if do_center_crop is True."""     )

      if do_rescale and rescale_factor is None:
         raise ValueError("""Rescale factor must be specified if do_rescale is True."""     )

      if do_normalize and (image_mean is None or image_std is None):
         raise ValueError("""Image mean and std must be specified if do_normalize is True."""     )

      # All transformations expect numpy arrays.
      __SCREAMING_SNAKE_CASE   				=							[to_numpy_array(lowerCamelCase     ) for image in images]

      if do_resize:
         __SCREAMING_SNAKE_CASE   				=							[self.resize(image=lowerCamelCase					,size=lowerCamelCase					,crop_pct=lowerCamelCase					,resample=lowerCamelCase     ) for image in images]

      if do_center_crop:
         __SCREAMING_SNAKE_CASE   				=							[self.center_crop(image=lowerCamelCase					,size=lowerCamelCase     ) for image in images]

      if do_rescale:
         __SCREAMING_SNAKE_CASE   				=							[self.rescale(image=lowerCamelCase					,scale=lowerCamelCase     ) for image in images]

      if do_normalize:
         __SCREAMING_SNAKE_CASE   				=							[self.normalize(image=lowerCamelCase					,mean=lowerCamelCase					,std=lowerCamelCase     ) for image in images]

      __SCREAMING_SNAKE_CASE   				=							[to_channel_dimension_format(lowerCamelCase					,lowerCamelCase     ) for image in images]

      __SCREAMING_SNAKE_CASE   				=							{"""pixel_values""": images}
      return BatchFeature(data=lowerCamelCase					,tensor_type=lowerCamelCase     )







"""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 					__a     ( unittest.TestCase       ):



							'''simple docstring'''







							def   SCREAMING_SNAKE_CASE						(     self       )			->							int:




										'''simple docstring'''
										# A mock response for an HTTP head request to emulate server down
										__lowercase       =       mock.Mock()
										__lowercase       =       500
										__lowercase       =       {}
										__lowercase       =       HTTPError
										__lowercase       =       {}

										# Download this model to make sure it's in the cache.
										__lowercase       =       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=_lowerCamelCase       ) as mock_head:
													__lowercase       =       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   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										# A mock response for an HTTP head request to emulate server down
										__lowercase       =       mock.Mock()
										__lowercase       =       500
										__lowercase       =       {}
										__lowercase       =       HTTPError
										__lowercase       =       {}

										# Download this model to make sure it's in the cache.
										__lowercase       =       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=_lowerCamelCase       ) as mock_head:
													__lowercase       =       GPTaTokenizerFast.from_pretrained("gpt2"       )
													# This check we did call the fake head request
													mock_head.assert_called()
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Any:




										'''simple docstring'''
										# This test is for deprecated behavior and can be removed in v5
										try:
													__lowercase       =       tempfile.mktemp()
													with open(_lowerCamelCase  ,    "wb"       ) as f:
																http_get("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"  ,    _lowerCamelCase       )

													__lowercase       =       AlbertTokenizer.from_pretrained(_lowerCamelCase       )
										finally:
													os.remove(_lowerCamelCase       )

										# 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"  ,    _lowerCamelCase       )
													__lowercase       =       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  ,    1_000       )
													# Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

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





							def   SCREAMING_SNAKE_CASE						(     self       )			->							int:




										'''simple docstring'''
										# This test is for deprecated behavior and can be removed in v5
										__lowercase       =       AlbertTokenizer.from_pretrained("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"       )





@is_staging_test
class 					__a     ( unittest.TestCase       ):



							'''simple docstring'''







							_lowerCamelCase					:			str          =   ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]
							@classmethod
							def   SCREAMING_SNAKE_CASE						(     cls       )			->							List[Any]:




										'''simple docstring'''
										__lowercase       =       TOKEN
										HfFolder.save_token(_lowerCamelCase       )
							@classmethod
							def   SCREAMING_SNAKE_CASE						(     cls       )			->							List[str]:




										'''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   SCREAMING_SNAKE_CASE						(     self       )			->							Any:




										'''simple docstring'''
										with tempfile.TemporaryDirectory() as tmp_dir:
													__lowercase       =       os.path.join(_lowerCamelCase  ,    "vocab.txt"       )
													with open(_lowerCamelCase  ,    "w"  ,    encoding="utf-8"       ) as vocab_writer:
																vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]       )       )
													__lowercase       =       BertTokenizer(_lowerCamelCase       )

										tokenizer.push_to_hub("test-tokenizer"  ,    use_auth_token=self._token       )
										__lowercase       =       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(_lowerCamelCase  ,    repo_id="test-tokenizer"  ,    push_to_hub=_lowerCamelCase  ,    use_auth_token=self._token       )

										__lowercase       =       BertTokenizer.from_pretrained(f'''{USER}/test-tokenizer'''       )
										self.assertDictEqual(new_tokenizer.vocab  ,    tokenizer.vocab       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										with tempfile.TemporaryDirectory() as tmp_dir:
													__lowercase       =       os.path.join(_lowerCamelCase  ,    "vocab.txt"       )
													with open(_lowerCamelCase  ,    "w"  ,    encoding="utf-8"       ) as vocab_writer:
																vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]       )       )
													__lowercase       =       BertTokenizer(_lowerCamelCase       )

										tokenizer.push_to_hub("valid_org/test-tokenizer-org"  ,    use_auth_token=self._token       )
										__lowercase       =       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(
													    _lowerCamelCase  ,    repo_id="valid_org/test-tokenizer-org"  ,    push_to_hub=_lowerCamelCase  ,    use_auth_token=self._token       )

										__lowercase       =       BertTokenizer.from_pretrained("valid_org/test-tokenizer-org"       )
										self.assertDictEqual(new_tokenizer.vocab  ,    tokenizer.vocab       )





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




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

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

										__lowercase       =       AutoTokenizer.from_pretrained(f'''{USER}/test-dynamic-tokenizer'''  ,    trust_remote_code=_lowerCamelCase       )
										# 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:
													__lowercase       =       os.path.join(_lowerCamelCase  ,    "vocab.txt"       )
													with open(_lowerCamelCase  ,    "w"  ,    encoding="utf-8"       ) as vocab_writer:
																vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]       )       )

													__lowercase       =       BertTokenizerFast.from_pretrained(_lowerCamelCase       )
													bert_tokenizer.save_pretrained(_lowerCamelCase       )
													__lowercase       =       CustomTokenizerFast.from_pretrained(_lowerCamelCase       )

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

										__lowercase       =       AutoTokenizer.from_pretrained(f'''{USER}/test-dynamic-tokenizer'''  ,    trust_remote_code=_lowerCamelCase       )
										# 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"       )
										__lowercase       =       AutoTokenizer.from_pretrained(
										    f'''{USER}/test-dynamic-tokenizer'''  ,    use_fast=_lowerCamelCase  ,    trust_remote_code=_lowerCamelCase       )
										# 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 					__a     ( unittest.TestCase       ):



							'''simple docstring'''







							def   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										__lowercase       =       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   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										__lowercase       =       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   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										__lowercase       =       Trie()
										trie.add("A"       )
										self.assertEqual(trie.split("ABC"       )  ,    ["A", "BC"]       )
										self.assertEqual(trie.split("BCA"       )  ,    ["BC", "A"]       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							str:




										'''simple docstring'''
										__lowercase       =       Trie()
										trie.add("TOKEN]"       )
										trie.add("[SPECIAL_TOKEN]"       )
										self.assertEqual(trie.split("This is something [SPECIAL_TOKEN]"       )  ,    ["This is something ", "[SPECIAL_TOKEN]"]       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Union[str, Any]:




										'''simple docstring'''
										__lowercase       =       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   SCREAMING_SNAKE_CASE						(     self       )			->							Any:




										'''simple docstring'''
										__lowercase       =       Trie()
										trie.add("AB"       )
										trie.add("B"       )
										trie.add("C"       )
										self.assertEqual(trie.split("ABC"       )  ,    ["AB", "C"]       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										__lowercase       =       Trie()
										trie.add("ABC"       )
										trie.add("B"       )
										trie.add("CD"       )
										self.assertEqual(trie.split("ABCD"       )  ,    ["ABC", "D"]       )





							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										# Even if the offsets are wrong, we necessarily output correct string
										# parts.
										__lowercase       =       Trie()
										__lowercase       =       trie.cut_text("ABC"  ,    [0, 0, 2, 1, 2, 3]       )
										self.assertEqual(_lowerCamelCase  ,    ["AB", "C"]       )





