'''simple docstring'''







import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


UpperCamelCase_      	=	get_tests_dir('''fixtures/test_sentencepiece.model''')




@require_sentencepiece
@require_tokenizers
class _SCREAMING_SNAKE_CASE(							_UpperCamelCase						,						unittest.TestCase					):
						A_			:							Optional[int]     		= XLNetTokenizer
						A_			:							List[str]     		= XLNetTokenizerFast
						A_			:							int     		= True
						A_			:							Any     		= True




						def      __lowerCamelCase       (    self :       Optional[int]      )     ->				str:
													super().setUp()

													# We have a SentencePiece fixture for testing
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = XLNetTokenizer(UpperCamelCase_							,							keep_accents=UpperCamelCase_      )
													tokenizer.sanitize_special_tokens()
													tokenizer.save_pretrained(self.tmpdirname      )




						def      __lowerCamelCase       (    self :       List[str]      )     ->				List[Any]:
													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = """<s>"""
													SCREAMING_SNAKE_CASE__     :Tuple						    = 1

													self.assertEqual(self.get_tokenizer()._convert_token_to_id(UpperCamelCase_      )							,							UpperCamelCase_      )
													self.assertEqual(self.get_tokenizer()._convert_id_to_token(UpperCamelCase_      )							,							UpperCamelCase_      )




						def      __lowerCamelCase       (    self :       Optional[int]      )     ->				Tuple:
													SCREAMING_SNAKE_CASE__     :str						    = list(self.get_tokenizer().get_vocab().keys()      )

													self.assertEqual(vocab_keys[0]							,							'<unk>'      )
													self.assertEqual(vocab_keys[1]							,							'<s>'      )
													self.assertEqual(vocab_keys[-1]							,							'<eod>'      )
													self.assertEqual(len(UpperCamelCase_      )							,							10_06      )




						def      __lowerCamelCase       (    self :       Tuple      )     ->				Optional[int]:
													self.assertEqual(self.get_tokenizer().vocab_size							,							10_00      )




						def      __lowerCamelCase       (    self :       int      )     ->				Tuple:
													SCREAMING_SNAKE_CASE__     :Tuple						    = XLNetTokenizer(UpperCamelCase_							,							keep_accents=UpperCamelCase_      )

													SCREAMING_SNAKE_CASE__     :int						    = tokenizer.tokenize('This is a test'      )
													self.assertListEqual(UpperCamelCase_							,							['▁This', '▁is', '▁a', '▁t', 'est']      )

													self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase_      )							,							[2_85, 46, 10, 1_70, 3_82]      )

													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = tokenizer.tokenize('I was born in 92000, and this is falsé.'      )
													self.assertListEqual(
													    UpperCamelCase_							,							[
													        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',
													        'é',
													        '.',
													    ]							,							)
													SCREAMING_SNAKE_CASE__     :Any						    = tokenizer.convert_tokens_to_ids(UpperCamelCase_      )
													self.assertListEqual(UpperCamelCase_							,							[8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]      )

													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = tokenizer.convert_ids_to_tokens(UpperCamelCase_      )
													self.assertListEqual(
													    UpperCamelCase_							,							[
													        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>',
													        '.',
													    ]							,							)




						def      __lowerCamelCase       (    self :       Dict      )     ->				Optional[int]:
													SCREAMING_SNAKE_CASE__     :int						    = XLNetTokenizer(UpperCamelCase_							,							do_lower_case=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :Any						    = tokenizer.tokenize('I was born in 92000, and this is falsé.'      )
													self.assertListEqual(
													    UpperCamelCase_							,							[
													        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',
													        'se',
													        '.',
													    ]							,							)
													self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )							,							['▁he', 'll', 'o']      )




						def      __lowerCamelCase       (    self :       List[Any]      )     ->				List[Any]:
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = XLNetTokenizer(UpperCamelCase_							,							do_lower_case=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :int						    = tokenizer.tokenize('I was born in 92000, and this is falsé.'      )
													self.assertListEqual(
													    UpperCamelCase_							,							[
													        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',
													        'se',
													        '.',
													    ]							,							)




						@slow
						def      __lowerCamelCase       (    self :       Dict      )     ->				List[Any]:
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = XLNetTokenizer.from_pretrained('xlnet-base-cased'      )

													SCREAMING_SNAKE_CASE__     :Optional[int]						    = tokenizer.encode('sequence builders'							,							add_special_tokens=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :str						    = tokenizer.encode('multi-sequence build'							,							add_special_tokens=UpperCamelCase_      )

													SCREAMING_SNAKE_CASE__     :Dict						    = tokenizer.build_inputs_with_special_tokens(UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :str						    = tokenizer.build_inputs_with_special_tokens(UpperCamelCase_							,							UpperCamelCase_      )

													assert encoded_sentence == text + [4, 3]
													assert encoded_pair == text + [4] + text_a + [4, 3]




						@slow
						def      __lowerCamelCase       (    self :       Tuple      )     ->				List[Any]:
													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = {"""input_ids""": [[17, 2_14_42, 2_70, 17, 10, 1_46_45, 3_18, 34, 17, 45_46, 31_45, 7_87, 13, 77_52, 2_20_18, 23, 21, 17, 45_46, 31_45, 7_87, 13, 33_52, 1_44_31, 13, 55_00, 11, 11_76, 5_80, 13, 1_68_19, 47_97, 23, 17, 10, 1_71_35, 6_58, 19, 4_57, 79_32, 13, 1_84, 19, 31_54, 1_71_35, 64_68, 19, 14_04, 1_22_69, 19, 42_29, 53_56, 1_62_64, 46, 19, 17, 2_05_45, 1_03_95, 9, 9, 9, 11, 28, 64_21, 95_31, 2_07_29, 17, 10, 3_53, 1_70_22, 11, 21, 64_21, 95_31, 1_69_49, 17, 10, 1_15_09, 7_53, 11, 33, 95, 24_21, 73_85, 9_56, 1_44_31, 26_26, 25, 8_42, 73_85, 48_36, 21, 14_29, 22_72, 98_55, 31_20, 1_61, 2_47_38, 19, 1_32_03, 6_58, 2_18, 7_87, 21, 4_30, 1_84_82, 8_47, 26_37, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_22, 2_21_78, 27, 10_64, 22, 9_56, 13, 1_11_01, 14_29, 58_54, 2_43_13, 1_89_53, 40, 4_22, 2_43_66, 68, 17_58, 37, 1_04_83, 1_42_57, 31, 2_07, 2_63, 21, 2_03, 37_73, 25, 71, 97_35, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 20_49, 34_42, 17, 1_38_94, 33_80, 23, 95, 18, 1_76_34, 22_88, 9, 4, 3]], """token_type_ids""": [[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, 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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], """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], [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, 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, 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, 1, 1, 1, 1]]}  # noqa: E501
													# fmt: on

													self.tokenizer_integration_test_util(
													    expected_encoding=UpperCamelCase_							,							model_name='xlnet-base-cased'							,							revision='c841166438c31ec7ca9a106dee7bb312b73ae511'							,							)












import warnings
from typing import Dict, List, Optional, Tuple

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


a__		     =     logging.get_logger(__name__)


class    SCREAMING_SNAKE_CASE_				(       _UpperCamelCase   ):



	"""simple docstring"""


	__magic_name__   :       int      	=		['input_ids', 'attention_mask']






	def __init__(					self		:						List[Any]					,     lowerCAmelCase		:						Union[str, Any]="</s>"					,     lowerCAmelCase		:						Tuple="<unk>"					,     lowerCAmelCase		:						Union[str, Any]="<pad>"					,     lowerCAmelCase		:						Tuple=125					,     lowerCAmelCase		:						str=None					,     **lowerCAmelCase		:						Optional[Any]					,     )	->       None:







						"""simple docstring"""







						if extra_ids > 0 and additional_special_tokens is None:
											__UpperCamelCase					:	str             =      [F'''<extra_id_{i}>''' for i in range(lowerCAmelCase	)]
						elif extra_ids > 0 and additional_special_tokens is not None:
											# Check that we have the right number of extra_id special tokens
											__UpperCamelCase					:	Tuple             =      len(set(filter(lambda lowerCAmelCase	: bool("""extra_id""" in str(lowerCAmelCase	)	)					,     lowerCAmelCase	)	)	)
											if extra_tokens != extra_ids:
																raise ValueError(
																    F'''Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are'''
																    """ provided to ByT5Tokenizer. In this case the additional_special_tokens must include the"""
																    """ extra_ids tokens"""	)

						__UpperCamelCase					:	Tuple             =      AddedToken(lowerCAmelCase					,     lstrip=lowerCAmelCase					,     rstrip=lowerCAmelCase	) if isinstance(lowerCAmelCase					,     lowerCAmelCase	) else pad_token
						__UpperCamelCase					:	Tuple             =      AddedToken(lowerCAmelCase					,     lstrip=lowerCAmelCase					,     rstrip=lowerCAmelCase	) if isinstance(lowerCAmelCase					,     lowerCAmelCase	) else eos_token
						__UpperCamelCase					:	int             =      AddedToken(lowerCAmelCase					,     lstrip=lowerCAmelCase					,     rstrip=lowerCAmelCase	) if isinstance(lowerCAmelCase					,     lowerCAmelCase	) else unk_token

						super().__init__(
						    eos_token=lowerCAmelCase					,     unk_token=lowerCAmelCase					,     pad_token=lowerCAmelCase					,     extra_ids=lowerCAmelCase					,     additional_special_tokens=lowerCAmelCase					,     **lowerCAmelCase					,     )

						__UpperCamelCase					:	Any             =      extra_ids

						__UpperCamelCase					:	List[Any]             =      2**8  # utf is 8 bits

						# define special tokens dict
						__UpperCamelCase					:	Dict[int, str]             =      {
						    self.pad_token: 0,
						    self.eos_token: 1,
						    self.unk_token: 2,
						}
						__UpperCamelCase					:	int             =      len(self.special_tokens_encoder	)
						__UpperCamelCase					:	Tuple             =      len(lowerCAmelCase	)
						for i, token in enumerate(lowerCAmelCase	):
											__UpperCamelCase					:	Optional[int]             =      self.vocab_size + i - n
						__UpperCamelCase					:	Dict[str, int]             =      {v: k for k, v in self.special_tokens_encoder.items()}






	@property
	def 					lowerCamelCase__     (					self		:						Any	)	->       Optional[int]:







						"""simple docstring"""







						return self._utf_vocab_size + self._num_special_tokens + self._extra_ids






	def 					lowerCamelCase__     (					self		:						Optional[int]					,     lowerCAmelCase		:						List[int]					,     lowerCAmelCase		:						Optional[List[int]] = None					,     lowerCAmelCase		:						bool = False	)	->       List[int]:







						"""simple docstring"""







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

						# normal case: some special tokens
						if token_ids_a is None:
											return ([0] * len(lowerCAmelCase	)) + [1]
						return ([0] * len(lowerCAmelCase	)) + [1] + ([0] * len(lowerCAmelCase	)) + [1]






	def 					lowerCamelCase__     (					self		:						Tuple					,     lowerCAmelCase		:						List[int]	)	->       List[int]:







						"""simple docstring"""







						if len(lowerCAmelCase	) > 0 and token_ids[-1] == self.eos_token_id:
											warnings.warn(
											    F'''This sequence already has {self.eos_token}. In future versions this behavior may lead to duplicated'''
											    """ eos tokens being added."""	)
											return token_ids
						else:
											return token_ids + [self.eos_token_id]






	def 					lowerCamelCase__     (					self		:						List[Any]					,     lowerCAmelCase		:						List[int]					,     lowerCAmelCase		:						Optional[List[int]] = None	)	->       List[int]:







						"""simple docstring"""







						__UpperCamelCase					:	Any             =      [self.eos_token_id]

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






	def 					lowerCamelCase__     (					self		:						List[str]					,     lowerCAmelCase		:						List[int]					,     lowerCAmelCase		:						Optional[List[int]] = None	)	->       List[int]:







						"""simple docstring"""







						__UpperCamelCase					:	List[str]             =      self._add_eos_if_not_present(lowerCAmelCase	)
						if token_ids_a is None:
											return token_ids_a
						else:
											__UpperCamelCase					:	List[Any]             =      self._add_eos_if_not_present(lowerCAmelCase	)
											return token_ids_a + token_ids_a






	def 					lowerCamelCase__     (					self		:						str					,     lowerCAmelCase		:						str	)	->       List[str]:







						"""simple docstring"""







						__UpperCamelCase					:	Optional[int]             =      [chr(lowerCAmelCase	) for i in text.encode("""utf-8"""	)]
						return tokens






	def 					lowerCamelCase__     (					self		:						Union[str, Any]					,     lowerCAmelCase		:						Optional[int]	)	->       int:







						"""simple docstring"""







						if token in self.special_tokens_encoder:
											__UpperCamelCase					:	Dict             =      self.special_tokens_encoder[token]
						elif token in self.added_tokens_encoder:
											__UpperCamelCase					:	Tuple             =      self.added_tokens_encoder[token]
						elif len(lowerCAmelCase	) != 1:
											__UpperCamelCase					:	Dict             =      self.unk_token_id
						else:
											__UpperCamelCase					:	Union[str, Any]             =      ord(lowerCAmelCase	) + self._num_special_tokens
						return token_id






	def 					lowerCamelCase__     (					self		:						Union[str, Any]					,     lowerCAmelCase		:						Dict	)	->       Optional[Any]:







						"""simple docstring"""







						if index in self.special_tokens_decoder:
											__UpperCamelCase					:	str             =      self.special_tokens_decoder[index]
						else:
											__UpperCamelCase					:	Any             =      chr(index - self._num_special_tokens	)
						return token






	def 					lowerCamelCase__     (					self		:						str					,     lowerCAmelCase		:						List[Any]	)	->       List[Any]:







						"""simple docstring"""







						__UpperCamelCase					:	Union[str, Any]             =      b""""""
						for token in tokens:
											if token in self.special_tokens_decoder:
																__UpperCamelCase					:	Optional[Any]             =      self.special_tokens_decoder[token].encode("""utf-8"""	)
											elif token in self.added_tokens_decoder:
																__UpperCamelCase					:	Optional[int]             =      self.special_tokens_decoder[token].encode("""utf-8"""	)
											elif token in self.special_tokens_encoder:
																__UpperCamelCase					:	Tuple             =      token.encode("""utf-8"""	)
											elif token in self.added_tokens_encoder:
																__UpperCamelCase					:	Tuple             =      token.encode("""utf-8"""	)
											else:
																__UpperCamelCase					:	Union[str, Any]             =      bytes([ord(lowerCAmelCase	)]	)
											bstring += tok_string
						__UpperCamelCase					:	Optional[int]             =      bstring.decode("""utf-8"""					,     errors="""ignore"""	)
						return string






	def 					lowerCamelCase__     (					self		:						Optional[int]					,     lowerCAmelCase		:						str					,     lowerCAmelCase		:						Optional[str] = None	)	->       Tuple[str]:







						"""simple docstring"""







						return ()






