


import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    LiltForQuestionAnswering,
	    LiltForSequenceClassification,
	    LiltForTokenClassification,
	    LiltModel,
	)
	from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST
class 	lowerCamelCase_       :



					'''simple docstring'''







					def __init__(				self ,       snake_case_ ,       snake_case_=1_3 ,       snake_case_=7 ,       snake_case_=True ,       snake_case_=True ,       snake_case_=True ,       snake_case_=True ,       snake_case_=9_9 ,       snake_case_=2_4 ,       snake_case_=2 ,       snake_case_=6 ,       snake_case_=3_7 ,       snake_case_="gelu" ,       snake_case_=0.1 ,       snake_case_=0.1 ,       snake_case_=5_1_2 ,       snake_case_=1_6 ,       snake_case_=2 ,       snake_case_=0.0_2 ,       snake_case_=3 ,       snake_case_=None ,       snake_case_=1_0_0_0 ,       )   ->			Union[str, Any]:







								'''simple docstring'''

								__lowercase 					=   parent
								__lowercase 					=   batch_size
								__lowercase 					=   seq_length
								__lowercase 					=   is_training
								__lowercase 					=   use_input_mask
								__lowercase 					=   use_token_type_ids
								__lowercase 					=   use_labels
								__lowercase 					=   vocab_size
								__lowercase 					=   hidden_size
								__lowercase 					=   num_hidden_layers
								__lowercase 					=   num_attention_heads
								__lowercase 					=   intermediate_size
								__lowercase 					=   hidden_act
								__lowercase 					=   hidden_dropout_prob
								__lowercase 					=   attention_probs_dropout_prob
								__lowercase 					=   max_position_embeddings
								__lowercase 					=   type_vocab_size
								__lowercase 					=   type_sequence_label_size
								__lowercase 					=   initializer_range
								__lowercase 					=   num_labels
								__lowercase 					=   scope
								__lowercase 					=   range_bbox






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







								'''simple docstring'''

								__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.vocab_size						)

								__lowercase 					=   ids_tensor([self.batch_size, self.seq_length, 4] ,       self.range_bbox						)
								# Ensure that bbox is legal
								for i in range(bbox.shape[0]						):
											for j in range(bbox.shape[1]						):
														if bbox[i, j, 3] < bbox[i, j, 1]:
																	__lowercase 					=   bbox[i, j, 3]
																	__lowercase 					=   bbox[i, j, 1]
																	__lowercase 					=   t
														if bbox[i, j, 2] < bbox[i, j, 0]:
																	__lowercase 					=   bbox[i, j, 2]
																	__lowercase 					=   bbox[i, j, 0]
																	__lowercase 					=   t

								__lowercase 					=   None
								if self.use_input_mask:
											__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       vocab_size=2						)

								__lowercase 					=   None
								if self.use_token_type_ids:
											__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.type_vocab_size						)

								__lowercase 					=   None
								__lowercase 					=   None
								if self.use_labels:
											__lowercase 					=   ids_tensor([self.batch_size] ,       self.type_sequence_label_size						)
											__lowercase 					=   ids_tensor([self.batch_size, self.seq_length] ,       self.num_labels						)

								__lowercase 					=   self.get_config()

								return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels






					def A      (				self						)   ->			str:







								'''simple docstring'''

								return LiltConfig(
								    vocab_size=self.vocab_size ,       hidden_size=self.hidden_size ,       num_hidden_layers=self.num_hidden_layers ,       num_attention_heads=self.num_attention_heads ,       intermediate_size=self.intermediate_size ,       hidden_act=self.hidden_act ,       hidden_dropout_prob=self.hidden_dropout_prob ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob ,       max_position_embeddings=self.max_position_embeddings ,       type_vocab_size=self.type_vocab_size ,       initializer_range=self.initializer_range ,       )






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   LiltModel(config=A_						)
								model.to(A_						)
								model.eval()
								__lowercase 					=   model(A_ ,       bbox=A_ ,       attention_mask=A_ ,       token_type_ids=A_						)
								__lowercase 					=   model(A_ ,       bbox=A_ ,       token_type_ids=A_						)
								__lowercase 					=   model(A_ ,       bbox=A_						)

								self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, self.seq_length, self.hidden_size)						)
								self.parent.assertEqual(result.pooler_output.shape ,       (self.batch_size, self.hidden_size)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   self.num_labels
								__lowercase 					=   LiltForTokenClassification(config=A_						)
								model.to(A_						)
								model.eval()
								__lowercase 					=   model(
								    A_ ,       bbox=A_ ,       attention_mask=A_ ,       token_type_ids=A_ ,       labels=A_						)
								self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.num_labels)						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       )   ->			List[Any]:







								'''simple docstring'''

								__lowercase 					=   LiltForQuestionAnswering(config=A_						)
								model.to(A_						)
								model.eval()
								__lowercase 					=   model(
								    A_ ,       bbox=A_ ,       attention_mask=A_ ,       token_type_ids=A_ ,       start_positions=A_ ,       end_positions=A_ ,       )
								self.parent.assertEqual(result.start_logits.shape ,       (self.batch_size, self.seq_length)						)
								self.parent.assertEqual(result.end_logits.shape ,       (self.batch_size, self.seq_length)						)






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







								'''simple docstring'''

								__lowercase 					=   self.prepare_config_and_inputs()
								(
								    (
								    __lowercase      
								)					, (
								    __lowercase      
								)					, (
								    __lowercase      
								)					, (
								    __lowercase      
								)					, (
								    __lowercase      
								)					, (
								    __lowercase      
								)					, (
								    __lowercase      
								)					,       
								) 					=   config_and_inputs
								__lowercase 					=   {
								    '''input_ids''': input_ids,
								    '''bbox''': bbox,
								    '''token_type_ids''': token_type_ids,
								    '''attention_mask''': input_mask,
								}
								return config, inputs_dict




@require_torch
class 	lowerCamelCase_       (				_lowercase     ,     _lowercase     ,     _lowercase     ,     unittest.TestCase				):



					'''simple docstring'''







					__UpperCAmelCase            =				(
					    (
					        LiltModel,
					        LiltForSequenceClassification,
					        LiltForTokenClassification,
					        LiltForQuestionAnswering,
					    )
					    if is_torch_available()
					    else ()
					)
					__UpperCAmelCase            =				(
					    {
					        '''feature-extraction''': LiltModel,
					        '''question-answering''': LiltForQuestionAnswering,
					        '''text-classification''': LiltForSequenceClassification,
					        '''token-classification''': LiltForTokenClassification,
					        '''zero-shot''': LiltForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			int:







								'''simple docstring'''

								return True






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







								'''simple docstring'''

								__lowercase 					=   LiltModelTester(self						)
								__lowercase 					=   ConfigTester(self ,       config_class=A_ ,       hidden_size=3_7						)






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







								'''simple docstring'''

								self.config_tester.run_common_tests()






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*A_						)






					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
											__lowercase 					=   type
											self.model_tester.create_and_check_model(*A_						)






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







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*A_						)






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*A_						)






					@slow
					def A      (				self						)   ->			List[Any]:







								'''simple docstring'''

								for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 					=   LiltModel.from_pretrained(A_						)
											self.assertIsNotNone(A_						)




@require_torch
@slow
class 	lowerCamelCase_       (				unittest.TestCase				):



					'''simple docstring'''







					def A      (				self						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base'''						).to(A_						)

								__lowercase 					=   torch.tensor([[1, 2]] ,       device=A_						)
								__lowercase 					=   torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]] ,       device=A_						)

								# forward pass
								with torch.no_grad():
											__lowercase 					=   model(input_ids=A_ ,       bbox=A_						)

								__lowercase 					=   torch.Size([1, 2, 7_6_8]						)
								__lowercase 					=   torch.tensor(
								    [[-0.0_6_5_3, 0.0_9_5_0, -0.0_0_6_1], [-0.0_5_4_5, 0.0_9_2_6, -0.0_3_2_4]] ,       device=A_ ,       )

								self.assertTrue(outputs.last_hidden_state.shape ,       A_						)
								self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3] ,       A_ ,       atol=1e-3						)						)






import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


a : Union[str, Any]		=				logging.get_logger(__name__)


a : Union[str, Any]		=				{'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

a : Union[str, Any]		=				{
    '''vocab_file''': {
        '''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json''',
        '''allenai/longformer-large-4096''': (
            '''https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json'''
        ),
        '''allenai/longformer-large-4096-finetuned-triviaqa''': (
            '''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json'''
        ),
        '''allenai/longformer-base-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json'''
        ),
        '''allenai/longformer-large-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json'''
        ),
    },
    '''merges_file''': {
        '''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt''',
        '''allenai/longformer-large-4096''': (
            '''https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt'''
        ),
        '''allenai/longformer-large-4096-finetuned-triviaqa''': (
            '''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt'''
        ),
        '''allenai/longformer-base-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt'''
        ),
        '''allenai/longformer-large-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt'''
        ),
    },
}

a : Dict		=				{
    '''allenai/longformer-base-4096''': 4096,
    '''allenai/longformer-large-4096''': 4096,
    '''allenai/longformer-large-4096-finetuned-triviaqa''': 4096,
    '''allenai/longformer-base-4096-extra.pos.embd.only''': 4096,
    '''allenai/longformer-large-4096-extra.pos.embd.only''': 4096,
}


@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def 		lowercase_  (     ):


			'''simple docstring'''







			__lowercase 					=   (
			    list(range(ord('''!'''  )       ,			ord('''~'''  ) + 1  )  ) + list(range(ord('''¡'''  )       ,			ord('''¬'''  ) + 1  )  ) + list(range(ord('''®'''  )       ,			ord('''ÿ'''  ) + 1  )  )
			)
			__lowercase 					=   bs[:]
			__lowercase 					=   0
			for b in range(2**8  ):
						if b not in bs:
									bs.append(_UpperCamelCase  )
									cs.append(2**8 + n  )
									n += 1
			__lowercase 					=   [chr(_UpperCamelCase  ) for n in cs]
			return dict(zip(_UpperCamelCase       ,			_UpperCamelCase  )  )


def 		lowercase_  (     _UpperCamelCase  ):


			'''simple docstring'''







			__lowercase 					=   set()
			__lowercase 					=   word[0]
			for char in word[1:]:
						pairs.add((prev_char, char)  )
						__lowercase 					=   char
			return pairs





class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				VOCAB_FILES_NAMES
					__UpperCAmelCase            =				PRETRAINED_VOCAB_FILES_MAP
					__UpperCAmelCase            =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					__UpperCAmelCase            =				["input_ids", "attention_mask"]






					def __init__(				self ,       snake_case_ ,       snake_case_ ,       snake_case_="replace" ,       snake_case_="<s>" ,       snake_case_="</s>" ,       snake_case_="</s>" ,       snake_case_="<s>" ,       snake_case_="<unk>" ,       snake_case_="<pad>" ,       snake_case_="<mask>" ,       snake_case_=False ,       **snake_case_ ,       )   ->			Optional[int]:







								'''simple docstring'''

								__lowercase 					=   AddedToken(snake_case_ ,       lstrip=snake_case_ ,       rstrip=snake_case_						) if isinstance(snake_case_ ,       snake_case_						) else bos_token
								__lowercase 					=   AddedToken(snake_case_ ,       lstrip=snake_case_ ,       rstrip=snake_case_						) if isinstance(snake_case_ ,       snake_case_						) else eos_token
								__lowercase 					=   AddedToken(snake_case_ ,       lstrip=snake_case_ ,       rstrip=snake_case_						) if isinstance(snake_case_ ,       snake_case_						) else sep_token
								__lowercase 					=   AddedToken(snake_case_ ,       lstrip=snake_case_ ,       rstrip=snake_case_						) if isinstance(snake_case_ ,       snake_case_						) else cls_token
								__lowercase 					=   AddedToken(snake_case_ ,       lstrip=snake_case_ ,       rstrip=snake_case_						) if isinstance(snake_case_ ,       snake_case_						) else unk_token
								__lowercase 					=   AddedToken(snake_case_ ,       lstrip=snake_case_ ,       rstrip=snake_case_						) if isinstance(snake_case_ ,       snake_case_						) else pad_token

								# Mask token behave like a normal word, i.e. include the space before it
								__lowercase 					=   AddedToken(snake_case_ ,       lstrip=snake_case_ ,       rstrip=snake_case_						) if isinstance(snake_case_ ,       snake_case_						) else mask_token

								super().__init__(
								    errors=snake_case_ ,       bos_token=snake_case_ ,       eos_token=snake_case_ ,       unk_token=snake_case_ ,       sep_token=snake_case_ ,       cls_token=snake_case_ ,       pad_token=snake_case_ ,       mask_token=snake_case_ ,       add_prefix_space=snake_case_ ,       **snake_case_ ,       )

								with open(snake_case_ ,       encoding='''utf-8'''						) as vocab_handle:
											__lowercase 					=   json.load(snake_case_						)
								__lowercase 					=   {v: k for k, v in self.encoder.items()}
								__lowercase 					=   errors  # how to handle errors in decoding
								__lowercase 					=   bytes_to_unicode()
								__lowercase 					=   {v: k for k, v in self.byte_encoder.items()}
								with open(snake_case_ ,       encoding='''utf-8'''						) as merges_handle:
											__lowercase 					=   merges_handle.read().split('''\n'''						)[1:-1]
								__lowercase 					=   [tuple(merge.split()						) for merge in bpe_merges]
								__lowercase 					=   dict(zip(snake_case_ ,       range(len(snake_case_						)						)						)						)
								__lowercase 					=   {}
								__lowercase 					=   add_prefix_space

								# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
								__lowercase 					=   re.compile(r'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+'''						)






					@property
					def A      (				self						)   ->			List[str]:







								'''simple docstring'''

								return len(self.encoder						)






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







								'''simple docstring'''

								return dict(self.encoder ,       **self.added_tokens_encoder						)






					def A      (				self ,       snake_case_						)   ->			List[str]:







								'''simple docstring'''

								if token in self.cache:
											return self.cache[token]
								__lowercase 					=   tuple(snake_case_						)
								__lowercase 					=   get_pairs(snake_case_						)

								if not pairs:
											return token

								while True:
											__lowercase 					=   min(snake_case_ ,       key=lambda snake_case_						: self.bpe_ranks.get(snake_case_ ,       float('''inf'''						)						)						)
											if bigram not in self.bpe_ranks:
														break
											__lowercase					, __lowercase 					=   bigram
											__lowercase 					=   []
											__lowercase 					=   0
											while i < len(snake_case_						):
														try:
																	__lowercase 					=   word.index(snake_case_ ,       snake_case_						)
														except ValueError:
																	new_word.extend(word[i:]						)
																	break
														else:
																	new_word.extend(word[i:j]						)
																	__lowercase 					=   j

														if word[i] == first and i < len(snake_case_						) - 1 and word[i + 1] == second:
																	new_word.append(first + second						)
																	i += 2
														else:
																	new_word.append(word[i]						)
																	i += 1
											__lowercase 					=   tuple(snake_case_						)
											__lowercase 					=   new_word
											if len(snake_case_						) == 1:
														break
											else:
														__lowercase 					=   get_pairs(snake_case_						)
								__lowercase 					=   ''' '''.join(snake_case_						)
								__lowercase 					=   word
								return word






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







								'''simple docstring'''

								__lowercase 					=   []
								for token in re.findall(self.pat ,       snake_case_						):
											__lowercase 					=   ''''''.join(
											    self.byte_encoder[b] for b in token.encode('''utf-8'''						)						)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
											bpe_tokens.extend(bpe_token for bpe_token in self.bpe(snake_case_						).split(''' '''						)						)
								return bpe_tokens






					def A      (				self ,       snake_case_						)   ->			Any:







								'''simple docstring'''

								return self.encoder.get(snake_case_ ,       self.encoder.get(self.unk_token						)						)






					def A      (				self ,       snake_case_						)   ->			Dict:







								'''simple docstring'''

								return self.decoder.get(snake_case_						)






					def A      (				self ,       snake_case_						)   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   ''''''.join(snake_case_						)
								__lowercase 					=   bytearray([self.byte_decoder[c] for c in text]						).decode('''utf-8''' ,       errors=self.errors						)
								return text






					def A      (				self ,       snake_case_ ,       snake_case_ = None						)   ->			Tuple[str]:







								'''simple docstring'''

								if not os.path.isdir(snake_case_						):
											logger.error(F'Vocabulary path ({save_directory}) should be a directory'						)
											return
								__lowercase 					=   os.path.join(
								    snake_case_ ,       (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']						)
								__lowercase 					=   os.path.join(
								    snake_case_ ,       (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']						)

								with open(snake_case_ ,       '''w''' ,       encoding='''utf-8'''						) as f:
											f.write(json.dumps(self.encoder ,       indent=2 ,       sort_keys=snake_case_ ,       ensure_ascii=snake_case_						) + '''\n'''						)

								__lowercase 					=   0
								with open(snake_case_ ,       '''w''' ,       encoding='''utf-8'''						) as writer:
											writer.write('''#version: 0.2\n'''						)
											for bpe_tokens, token_index in sorted(self.bpe_ranks.items() ,       key=lambda snake_case_						: kv[1]						):
														if index != token_index:
																	logger.warning(
																	    F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
																	    ''' Please check that the tokenizer is not corrupted!'''						)
																	__lowercase 					=   token_index
														writer.write(''' '''.join(snake_case_						) + '''\n'''						)
														index += 1

								return vocab_file, merge_file






					def A      (				self ,       snake_case_ ,       snake_case_ = None						)   ->			List[int]:







								'''simple docstring'''

								if token_ids_a is None:
											return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
								__lowercase 					=   [self.cls_token_id]
								__lowercase 					=   [self.sep_token_id]
								return cls + token_ids_a + sep + sep + token_ids_a + sep






					def A      (				self ,       snake_case_ ,       snake_case_ = None ,       snake_case_ = False						)   ->			List[int]:







								'''simple docstring'''

								if already_has_special_tokens:
											return super().get_special_tokens_mask(
											    token_ids_a=snake_case_ ,       token_ids_a=snake_case_ ,       already_has_special_tokens=snake_case_						)

								if token_ids_a is None:
											return [1] + ([0] * len(snake_case_						)) + [1]
								return [1] + ([0] * len(snake_case_						)) + [1, 1] + ([0] * len(snake_case_						)) + [1]






					def A      (				self ,       snake_case_ ,       snake_case_ = None						)   ->			List[int]:







								'''simple docstring'''

								__lowercase 					=   [self.sep_token_id]
								__lowercase 					=   [self.cls_token_id]

								if token_ids_a is None:
											return len(cls + token_ids_a + sep						) * [0]
								return len(cls + token_ids_a + sep + sep + token_ids_a + sep						) * [0]






					def A      (				self ,       snake_case_ ,       snake_case_=False ,       **snake_case_						)   ->			Union[str, Any]:







								'''simple docstring'''

								__lowercase 					=   kwargs.pop('''add_prefix_space''' ,       self.add_prefix_space						)
								if (is_split_into_words or add_prefix_space) and (len(snake_case_						) > 0 and not text[0].isspace()):
											__lowercase 					=   ''' ''' + text
								return (text, kwargs)


