





'''simple docstring'''



import argparse
import gc
import json
import os
import re

import torch
from huggingface_hub import hf_hub_download

from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedTokenizerFast, RwkvConfig
from transformers.modeling_utils import WEIGHTS_INDEX_NAME, shard_checkpoint


_SCREAMING_SNAKE_CASE   =      {
    '''169M''': 1_2,
    '''430M''': 2_4,
    '''1B5''': 2_4,
    '''3B''': 3_2,
    '''7B''': 3_2,
    '''14B''': 4_0,
}

_SCREAMING_SNAKE_CASE   =      {
    '''169M''': 7_6_8,
    '''430M''': 1_0_2_4,
    '''1B5''': 2_0_4_8,
    '''3B''': 2_5_6_0,
    '''7B''': 4_0_9_6,
    '''14B''': 5_1_2_0,
}




def 				_lowerCAmelCase  (			lowerCamelCase_     :					Dict			):
			__lowercase			  =							list(state_dict.keys()			)
			for name in state_dict_keys:
						__lowercase			  =							state_dict.pop(lowerCamelCase_			)
						# emb -> embedding
						if name.startswith('''emb.'''			):
									__lowercase			  =							name.replace('''emb.'''						,    '''embeddings.'''			)
						# ln_0 -> pre_ln (only present at block 0)
						if name.startswith('''blocks.0.ln0'''			):
									__lowercase			  =							name.replace('''blocks.0.ln0'''						,    '''blocks.0.pre_ln'''			)
						# att -> attention
						__lowercase			  =							re.sub(r'''blocks\.(\d+)\.att'''						,    r'''blocks.\1.attention'''						,    lowerCamelCase_			)
						# ffn -> feed_forward
						__lowercase			  =							re.sub(r'''blocks\.(\d+)\.ffn'''						,    r'''blocks.\1.feed_forward'''						,    lowerCamelCase_			)
						# time_mix_k -> time_mix_key and reshape
						if name.endswith('''.time_mix_k'''			):
									__lowercase			  =							name.replace('''.time_mix_k'''						,    '''.time_mix_key'''			)
						# time_mix_v -> time_mix_value and reshape
						if name.endswith('''.time_mix_v'''			):
									__lowercase			  =							name.replace('''.time_mix_v'''						,    '''.time_mix_value'''			)
						# time_mix_r -> time_mix_key and reshape
						if name.endswith('''.time_mix_r'''			):
									__lowercase			  =							name.replace('''.time_mix_r'''						,    '''.time_mix_receptance'''			)

						if name != "head.weight":
									__lowercase			  =							'''rwkv.''' + name

						__lowercase			  =							weight
			return state_dict




def 				_lowerCAmelCase  (			lowerCamelCase_     :					Optional[int]						,    lowerCamelCase_     :					Union[str, Any]						,    lowerCamelCase_     :					List[str]						,    lowerCamelCase_     :					List[Any]=None						,    lowerCamelCase_     :					List[Any]=None						,    lowerCamelCase_     :					Any=False						,    lowerCamelCase_     :					int=None			):
			# 1. If possible, build the tokenizer.
			if tokenizer_file is None:
						print('''No `--tokenizer_file` provided, we will use the default tokenizer.'''			)
						__lowercase			  =							5_0_2_7_7
						__lowercase			  =							AutoTokenizer.from_pretrained('''EleutherAI/gpt-neox-20b'''			)
			else:
						__lowercase			  =							PreTrainedTokenizerFast(tokenizer_file=lowerCamelCase_			)
						__lowercase			  =							len(lowerCamelCase_			)
			tokenizer.save_pretrained(lowerCamelCase_			)

			# 2. Build the config
			__lowercase			  =							list(NUM_HIDDEN_LAYERS_MAPPING.keys()			)
			if size is None:
						# Try to infer size from the checkpoint name
						for candidate in possible_sizes:
									if candidate in checkpoint_file:
												__lowercase			  =							candidate
												break
						if size is None:
									raise ValueError('''Could not infer the size, please provide it with the `--size` argument.'''			)
			if size not in possible_sizes:
						raise ValueError(f"`size` should be one of {possible_sizes}, got {size}."			)

			__lowercase			  =							RwkvConfig(
			    vocab_size=lowerCamelCase_						,    num_hidden_layers=NUM_HIDDEN_LAYERS_MAPPING[size]						,    hidden_size=HIDEN_SIZE_MAPPING[size]						,    )
			config.save_pretrained(lowerCamelCase_			)

			# 3. Download model file then convert state_dict
			__lowercase			  =							hf_hub_download(lowerCamelCase_						,    lowerCamelCase_			)
			__lowercase			  =							torch.load(lowerCamelCase_						,    map_location='''cpu'''			)
			__lowercase			  =							convert_state_dict(lowerCamelCase_			)

			# 4. Split in shards and save
			__lowercase  ,						__lowercase			  =							shard_checkpoint(lowerCamelCase_			)
			for shard_file, shard in shards.items():
						torch.save(lowerCamelCase_						,    os.path.join(lowerCamelCase_						,    lowerCamelCase_			)			)

			if index is not None:
						__lowercase			  =							os.path.join(lowerCamelCase_						,    lowerCamelCase_			)
						# Save the index as well
						with open(lowerCamelCase_						,    '''w'''						,    encoding='''utf-8'''			) as f:
									__lowercase			  =							json.dumps(lowerCamelCase_						,    indent=2						,    sort_keys=lowerCamelCase_			) + '''\n'''
									f.write(lowerCamelCase_			)

						# 5. Clean up shards (for some reason the file PyTorch saves take the same space as the whole state_dict
						print(
						    '''Cleaning up shards. This may error with an OOM error, it this is the case don\'t worry you still have converted the model.'''			)
						__lowercase			  =							list(shards.keys()			)

						del state_dict
						del shards
						gc.collect()

						for shard_file in shard_files:
									__lowercase			  =							torch.load(os.path.join(lowerCamelCase_						,    lowerCamelCase_			)			)
									torch.save({k: v.cpu().clone() for k, v in state_dict.items()}						,    os.path.join(lowerCamelCase_						,    lowerCamelCase_			)			)

			del state_dict
			gc.collect()

			if push_to_hub:
						if model_name is None:
									raise ValueError('''Please provide a `model_name` to push the model to the Hub.'''			)
						__lowercase			  =							AutoModelForCausalLM.from_pretrained(lowerCamelCase_			)
						model.push_to_hub(lowerCamelCase_						,    max_shard_size='''2GB'''			)
						tokenizer.push_to_hub(lowerCamelCase_			)


if __name__ == "__main__":
	_SCREAMING_SNAKE_CASE   =      argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '''--repo_id''', default=None, type=str, required=True, help='''Repo ID from which to pull the checkpoint.'''
	)
	parser.add_argument(
	    '''--checkpoint_file''', default=None, type=str, required=True, help='''Name of the checkpoint file in the repo.'''
	)
	parser.add_argument(
	    '''--output_dir''', default=None, type=str, required=True, help='''Where to save the converted model.'''
	)
	parser.add_argument(
	    '''--tokenizer_file''',
	    default=None,
	    type=str,
	    help='''Path to the tokenizer file to use (if not provided, only the model is converted).''',
	)
	parser.add_argument(
	    '''--size''',
	    default=None,
	    type=str,
	    help='''Size of the model. Will be inferred from the `checkpoint_file` if not passed.''',
	)
	parser.add_argument(
	    '''--push_to_hub''',
	    action='''store_true''',
	    help='''Push to the Hub the converted model.''',
	)
	parser.add_argument(
	    '''--model_name''',
	    default=None,
	    type=str,
	    help='''Name of the pushed model on the Hub, including the username / organization.''',
	)

	_SCREAMING_SNAKE_CASE   =      parser.parse_args()
	convert_rmkv_checkpoint_to_hf_format(
	    args.repo_id,
	    args.checkpoint_file,
	    args.output_dir,
	    size=args.size,
	    tokenizer_file=args.tokenizer_file,
	    push_to_hub=args.push_to_hub,
	    model_name=args.model_name,
	)












'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin






class 							__lowercase    ( lowerCAmelCase__	, unittest.TestCase  ):







	'''simple docstring'''

	a      :			List[Any]     =    CanineTokenizer
	a      :			Union[str, Any]     =    False


	def   _UpperCAmelCase       (self	)							->							Dict:







				'''simple docstring'''





				super().setUp()
				__lowercase			  =							CanineTokenizer()
				tokenizer.save_pretrained(self.tmpdirname	)


	@cached_property
	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				return CanineTokenizer.from_pretrained('''google/canine-s'''	)


	def   _UpperCAmelCase       (self       ,**_lowerCamelCase	)							->							CanineTokenizer:







				'''simple docstring'''





				__lowercase			  =							self.tokenizer_class.from_pretrained(self.tmpdirname       ,**_lowerCamelCase	)
				__lowercase			  =							1024
				return tokenizer


	@require_torch
	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				__lowercase			  =							self.canine_tokenizer
				__lowercase			  =							['''Life is like a box of chocolates.''', '''You never know what you\'re gonna get.''']
				# fmt: off
				__lowercase			  =							[57344, 76, 105, 102, 101, 32, 105, 115, 32, 108, 105, 107, 101, 32, 97, 32, 98, 111, 120, 32, 111, 102, 32, 99, 104, 111, 99, 111, 108, 97, 116, 101, 115, 46, 57345, 0, 0, 0, 0]
				# fmt: on
				__lowercase			  =							tokenizer(_lowerCamelCase       ,padding=_lowerCamelCase       ,return_tensors='''pt'''	)
				self.assertIsInstance(_lowerCamelCase       ,_lowerCamelCase	)

				__lowercase			  =							list(batch.input_ids.numpy()[0]	)

				self.assertListEqual(_lowerCamelCase       ,_lowerCamelCase	)

				self.assertEqual((2, 39)       ,batch.input_ids.shape	)
				self.assertEqual((2, 39)       ,batch.attention_mask.shape	)


	@require_torch
	def   _UpperCAmelCase       (self	)							->							Tuple:







				'''simple docstring'''





				__lowercase			  =							self.canine_tokenizer
				__lowercase			  =							['''Once there was a man.''', '''He wrote a test in HuggingFace Tranformers.''']
				__lowercase			  =							tokenizer(_lowerCamelCase       ,padding=_lowerCamelCase       ,return_tensors='''pt'''	)
				# check if input_ids, attention_mask and token_type_ids are returned
				self.assertIn('''input_ids'''       ,_lowerCamelCase	)
				self.assertIn('''attention_mask'''       ,_lowerCamelCase	)
				self.assertIn('''token_type_ids'''       ,_lowerCamelCase	)


	@require_torch
	def   _UpperCAmelCase       (self	)							->							int:







				'''simple docstring'''





				__lowercase			  =							self.canine_tokenizer
				__lowercase			  =							[
				    '''What\'s the weater?''',
				    '''It\'s about 25 degrees.''',
				]
				__lowercase			  =							tokenizer(
				    text_target=_lowerCamelCase       ,max_length=32       ,padding='''max_length'''       ,truncation=_lowerCamelCase       ,return_tensors='''pt'''	)
				self.assertEqual(32       ,targets['''input_ids'''].shape[1]	)


	def   _UpperCAmelCase       (self	)							->							int:







				'''simple docstring'''





				__lowercase			  =							self.get_tokenizers()
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										self.assertNotEqual(tokenizer.model_max_length       ,42	)

        # Now let's start the test
				__lowercase			  =							self.get_tokenizers()
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										# Isolate this from the other tests because we save additional tokens/etc
										__lowercase			  =							tempfile.mkdtemp()

										__lowercase			  =							''' He is very happy, UNwant\u00E9d,running'''
										__lowercase			  =							tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										tokenizer.save_pretrained(_lowerCamelCase	)

										__lowercase			  =							tokenizer.__class__.from_pretrained(_lowerCamelCase	)
										__lowercase			  =							after_tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										self.assertListEqual(_lowerCamelCase       ,_lowerCamelCase	)

										shutil.rmtree(_lowerCamelCase	)

				__lowercase			  =							self.get_tokenizers(model_max_length=42	)
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										# Isolate this from the other tests because we save additional tokens/etc
										__lowercase			  =							tempfile.mkdtemp()

										__lowercase			  =							''' He is very happy, UNwant\u00E9d,running'''

										__lowercase			  =							tokenizer.additional_special_tokens

										# We can add a new special token for Canine as follows:
										__lowercase			  =							chr(0xe_0_0_7	)
										additional_special_tokens.append(_lowerCamelCase	)
										tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens}	)
										__lowercase			  =							tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										tokenizer.save_pretrained(_lowerCamelCase	)

										__lowercase			  =							tokenizer.__class__.from_pretrained(_lowerCamelCase	)
										__lowercase			  =							after_tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										self.assertListEqual(_lowerCamelCase       ,_lowerCamelCase	)
										self.assertIn(_lowerCamelCase       ,after_tokenizer.additional_special_tokens	)
										self.assertEqual(after_tokenizer.model_max_length       ,42	)

										__lowercase			  =							tokenizer.__class__.from_pretrained(_lowerCamelCase       ,model_max_length=43	)
										self.assertEqual(tokenizer.model_max_length       ,43	)

										shutil.rmtree(_lowerCamelCase	)


	def   _UpperCAmelCase       (self	)							->							Dict:







				'''simple docstring'''





				__lowercase			  =							self.get_tokenizers(do_lower_case=_lowerCamelCase	)
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										__lowercase  ,						__lowercase			  =							self.get_clean_sequence(_lowerCamelCase	)

										# a special token for Canine can be defined as follows:
										__lowercase			  =							0xe_0_0_5
										__lowercase			  =							chr(_lowerCamelCase	)

										tokenizer.add_special_tokens({'''cls_token''': special_token}	)
										__lowercase			  =							tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										self.assertEqual(len(_lowerCamelCase	)       ,1	)

										__lowercase			  =							tokenizer.decode(ids + encoded_special_token       ,clean_up_tokenization_spaces=_lowerCamelCase	)
										__lowercase			  =							tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)

										__lowercase			  =							tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										__lowercase			  =							tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										self.assertEqual(_lowerCamelCase       ,input_encoded + special_token_id	)

										__lowercase			  =							tokenizer.decode(_lowerCamelCase       ,skip_special_tokens=_lowerCamelCase	)
										self.assertTrue(special_token not in decoded	)


	def   _UpperCAmelCase       (self	)							->							str:







				'''simple docstring'''





				__lowercase			  =							self.get_tokenizers(do_lower_case=_lowerCamelCase	)
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										__lowercase			  =							chr(0xe_0_0_5	)
										__lowercase			  =							chr(0xe_0_0_6	)

										# `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
										tokenizer.add_tokens([SPECIAL_TOKEN_1]       ,special_tokens=_lowerCamelCase	)
										# `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
										# which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
										tokenizer.add_special_tokens({'''additional_special_tokens''': [SPECIAL_TOKEN_2]}	)

										__lowercase			  =							tokenizer.tokenize(_lowerCamelCase	)
										__lowercase			  =							tokenizer.tokenize(_lowerCamelCase	)

										self.assertEqual(len(_lowerCamelCase	)       ,1	)
										self.assertEqual(len(_lowerCamelCase	)       ,1	)
										self.assertEqual(token_a[0]       ,_lowerCamelCase	)
										self.assertEqual(token_a[0]       ,_lowerCamelCase	)


	@require_tokenizers
	def   _UpperCAmelCase       (self	)							->							Dict:







				'''simple docstring'''





				__lowercase			  =							self.get_tokenizers(do_lower_case=_lowerCamelCase	)
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										# a special token for Canine can be defined as follows:
										__lowercase			  =							0xe_0_0_6
										__lowercase			  =							chr(_lowerCamelCase	)

										__lowercase			  =							AddedToken(_lowerCamelCase       ,lstrip=_lowerCamelCase	)
										tokenizer.add_special_tokens({'''additional_special_tokens''': [new_token]}	)

										with tempfile.TemporaryDirectory() as tmp_dir_name:
													tokenizer.save_pretrained(_lowerCamelCase	)
													tokenizer.from_pretrained(_lowerCamelCase	)


	def   _UpperCAmelCase       (self	)							->							int:







				'''simple docstring'''





				__lowercase			  =							[]
				if self.test_slow_tokenizer:
							tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())	)

				if self.test_rust_tokenizer:
							tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())	)

				for tokenizer_class, tokenizer_utils in tokenizer_list:
							with tempfile.TemporaryDirectory() as tmp_dir:
										tokenizer_utils.save_pretrained(_lowerCamelCase	)

										with open(os.path.join(_lowerCamelCase       ,'''special_tokens_map.json'''	)       ,encoding='''utf-8'''	) as json_file:
													__lowercase			  =							json.load(_lowerCamelCase	)

										with open(os.path.join(_lowerCamelCase       ,'''tokenizer_config.json'''	)       ,encoding='''utf-8'''	) as json_file:
													__lowercase			  =							json.load(_lowerCamelCase	)

										# a special token for Canine can be defined as follows:
										__lowercase			  =							0xe_0_0_6
										__lowercase			  =							chr(_lowerCamelCase	)

										__lowercase			  =							[new_token_a]
										__lowercase			  =							[new_token_a]

										with open(os.path.join(_lowerCamelCase       ,'''special_tokens_map.json'''	)       ,'''w'''       ,encoding='''utf-8'''	) as outfile:
													json.dump(_lowerCamelCase       ,_lowerCamelCase	)
										with open(os.path.join(_lowerCamelCase       ,'''tokenizer_config.json'''	)       ,'''w'''       ,encoding='''utf-8'''	) as outfile:
													json.dump(_lowerCamelCase       ,_lowerCamelCase	)

										# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
										# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
										# "special_tokens_map.json" files
										__lowercase			  =							tokenizer_class.from_pretrained(_lowerCamelCase       ,extra_ids=0	)
										self.assertIn(_lowerCamelCase       ,tokenizer_without_change_in_init.additional_special_tokens	)
										# self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
										self.assertEqual(
										    [new_token_a]       ,tokenizer_without_change_in_init.convert_ids_to_tokens(
										        tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]	)	)       ,)

										__lowercase			  =							0xe_0_0_7
										__lowercase			  =							chr(_lowerCamelCase	)
										# Now we test that we can change the value of additional_special_tokens in the from_pretrained
										__lowercase			  =							[AddedToken(_lowerCamelCase       ,lstrip=_lowerCamelCase	)]
										__lowercase			  =							tokenizer_class.from_pretrained(
										    _lowerCamelCase       ,additional_special_tokens=_lowerCamelCase       ,extra_ids=0	)

										self.assertIn(_lowerCamelCase       ,tokenizer.additional_special_tokens	)
										# self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
										self.assertEqual(
										    [new_token_a]       ,tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]	)	)	)


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







				'''simple docstring'''





				__lowercase			  =							self.get_tokenizers(do_lower_case=_lowerCamelCase	)
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										__lowercase			  =							'''hello world'''
										if self.space_between_special_tokens:
													__lowercase			  =							'''[CLS] hello world [SEP]'''
										else:
													__lowercase			  =							input
										__lowercase			  =							tokenizer.encode(_lowerCamelCase       ,add_special_tokens=_lowerCamelCase	)
										__lowercase			  =							tokenizer.decode(_lowerCamelCase       ,spaces_between_special_tokens=self.space_between_special_tokens	)
										self.assertIn(_lowerCamelCase       ,[output, output.lower()]	)


	def   _UpperCAmelCase       (self	)							->							Tuple:







				'''simple docstring'''





				__lowercase			  =							self.get_tokenizers()
				for tokenizer in tokenizers:
							with self.subTest(f"{tokenizer.__class__.__name__}"	):
										__lowercase			  =							[
										    '''bos_token''',
										    '''eos_token''',
										    '''unk_token''',
										    '''sep_token''',
										    '''pad_token''',
										    '''cls_token''',
										    '''mask_token''',
										]

				__lowercase			  =							'''a'''
				__lowercase			  =							ord(_lowerCamelCase	)

				for attr in attributes_list:
							setattr(_lowerCamelCase       ,attr + '''_id'''       ,_lowerCamelCase	)
							self.assertEqual(getattr(_lowerCamelCase       ,_lowerCamelCase	)       ,_lowerCamelCase	)
							self.assertEqual(getattr(_lowerCamelCase       ,attr + '''_id'''	)       ,_lowerCamelCase	)

							setattr(_lowerCamelCase       ,attr + '''_id'''       ,_lowerCamelCase	)
							self.assertEqual(getattr(_lowerCamelCase       ,_lowerCamelCase	)       ,_lowerCamelCase	)
							self.assertEqual(getattr(_lowerCamelCase       ,attr + '''_id'''	)       ,_lowerCamelCase	)

				setattr(_lowerCamelCase       ,'''additional_special_tokens_ids'''       ,[]	)
				self.assertListEqual(getattr(_lowerCamelCase       ,'''additional_special_tokens'''	)       ,[]	)
				self.assertListEqual(getattr(_lowerCamelCase       ,'''additional_special_tokens_ids'''	)       ,[]	)

				__lowercase			  =							0xe_0_0_6
				__lowercase			  =							chr(_lowerCamelCase	)
				setattr(_lowerCamelCase       ,'''additional_special_tokens_ids'''       ,[additional_special_token_id]	)
				self.assertListEqual(getattr(_lowerCamelCase       ,'''additional_special_tokens'''	)       ,[additional_special_token]	)
				self.assertListEqual(getattr(_lowerCamelCase       ,'''additional_special_tokens_ids'''	)       ,[additional_special_token_id]	)


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







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							Dict:







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							Tuple:







				'''simple docstring'''





				pass


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







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							int:







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							Any:







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							int:







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							Dict:







				'''simple docstring'''





				pass





