
import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY

@is_pipeline_test
class 							_UpperCamelCase					(       unittest.TestCase	):






			'''simple docstring'''

			__UpperCamelCase   :    Any          =			MODEL_FOR_MASKED_LM_MAPPING
			__UpperCamelCase   :    List[str]          =			TF_MODEL_FOR_MASKED_LM_MAPPING

			def    lowerCAmelCase__						(							self			:							List[Any]   ):
							super().tearDown()
							# clean-up as much as possible GPU memory occupied by PyTorch
							gc.collect()
							if is_torch_available():
											import torch

											torch.cuda.empty_cache()

			@require_tf
			def    lowerCAmelCase__						(							self			:							str   ):
							UpperCamelCase_:				List[Any]						=    pipeline(task="""fill-mask"""    ,						model="""sshleifer/tiny-distilroberta-base"""    ,						top_k=2    ,						framework="""tf"""   )
							UpperCamelCase_:				Optional[int]						=    unmasker("""My name is <mask>"""   )
							self.assertEqual(
							    nested_simplify(snake_case_    ,						decimals=6   )    ,						[
							        {"""sequence""": """My name is grouped""", """score""": 2.1e-05, """token""": 3_8015, """token_str""": """ grouped"""},
							        {"""sequence""": """My name is accuser""", """score""": 2.1e-05, """token""": 2_5506, """token_str""": """ accuser"""},
							    ]    ,						)

							UpperCamelCase_:				Union[str, Any]						=    unmasker("""The largest city in France is <mask>"""   )
							self.assertEqual(
							    nested_simplify(snake_case_    ,						decimals=6   )    ,						[
							        {
							            """sequence""": """The largest city in France is grouped""",
							            """score""": 2.1e-05,
							            """token""": 3_8015,
							            """token_str""": """ grouped""",
							        },
							        {
							            """sequence""": """The largest city in France is accuser""",
							            """score""": 2.1e-05,
							            """token""": 2_5506,
							            """token_str""": """ accuser""",
							        },
							    ]    ,						)

							UpperCamelCase_:				Any						=    unmasker("""My name is <mask>"""    ,						targets=[""" Patrick""", """ Clara""", """ Teven"""]    ,						top_k=3   )
							self.assertEqual(
							    nested_simplify(snake_case_    ,						decimals=6   )    ,						[
							        {"""sequence""": """My name is Clara""", """score""": 2e-05, """token""": 1_3606, """token_str""": """ Clara"""},
							        {"""sequence""": """My name is Patrick""", """score""": 2e-05, """token""": 3499, """token_str""": """ Patrick"""},
							        {"""sequence""": """My name is Te""", """score""": 1.9e-05, """token""": 2941, """token_str""": """ Te"""},
							    ]    ,						)

			@require_torch
			def    lowerCAmelCase__						(							self			:							Optional[int]   ):
							UpperCamelCase_:				Tuple						=    pipeline(task="""fill-mask"""    ,						model="""sshleifer/tiny-distilroberta-base"""    ,						top_k=2    ,						framework="""pt"""   )

							UpperCamelCase_:				int						=    unmasker("""My name is <mask>"""   )
							self.assertEqual(
							    nested_simplify(snake_case_    ,						decimals=6   )    ,						[
							        {"""sequence""": """My name is Maul""", """score""": 2.2e-05, """token""": 3_5676, """token_str""": """ Maul"""},
							        {"""sequence""": """My name isELS""", """score""": 2.2e-05, """token""": 1_6416, """token_str""": """ELS"""},
							    ]    ,						)

							UpperCamelCase_:				List[Any]						=    unmasker("""The largest city in France is <mask>"""   )
							self.assertEqual(
							    nested_simplify(snake_case_    ,						decimals=6   )    ,						[
							        {
							            """sequence""": """The largest city in France is Maul""",
							            """score""": 2.2e-05,
							            """token""": 3_5676,
							            """token_str""": """ Maul""",
							        },
							        {"""sequence""": """The largest city in France isELS""", """score""": 2.2e-05, """token""": 1_6416, """token_str""": """ELS"""},
							    ]    ,						)

							UpperCamelCase_:				Union[str, Any]						=    unmasker("""My name is <mask>"""    ,						targets=[""" Patrick""", """ Clara""", """ Teven"""]    ,						top_k=3   )
							self.assertEqual(
							    nested_simplify(snake_case_    ,						decimals=6   )    ,						[
							        {"""sequence""": """My name is Patrick""", """score""": 2.1e-05, """token""": 3499, """token_str""": """ Patrick"""},
							        {"""sequence""": """My name is Te""", """score""": 2e-05, """token""": 2941, """token_str""": """ Te"""},
							        {"""sequence""": """My name is Clara""", """score""": 2e-05, """token""": 1_3606, """token_str""": """ Clara"""},
							    ]    ,						)

							UpperCamelCase_:				str						=    unmasker("""My name is <mask> <mask>"""    ,						top_k=2   )

							self.assertEqual(
							    nested_simplify(snake_case_    ,						decimals=6   )    ,						[
							        [
							            {
							                """score""": 2.2e-05,
							                """token""": 3_5676,
							                """token_str""": """ Maul""",
							                """sequence""": """<s>My name is Maul<mask></s>""",
							            },
							            {"""score""": 2.2e-05, """token""": 1_6416, """token_str""": """ELS""", """sequence""": """<s>My name isELS<mask></s>"""},
							        ],
							        [
							            {
							                """score""": 2.2e-05,
							                """token""": 3_5676,
							                """token_str""": """ Maul""",
							                """sequence""": """<s>My name is<mask> Maul</s>""",
							            },
							            {"""score""": 2.2e-05, """token""": 1_6416, """token_str""": """ELS""", """sequence""": """<s>My name is<mask>ELS</s>"""},
							        ],
							    ]    ,						)

			@require_torch_gpu
			def    lowerCAmelCase__						(							self			:							Tuple   ):
							UpperCamelCase_:				int						=    pipeline("""fill-mask"""    ,						model="""hf-internal-testing/tiny-random-distilbert"""    ,						device=0    ,						framework="""pt"""   )

							# convert model to fp16
							pipe.model.half()

							UpperCamelCase_:				Dict						=    pipe("""Paris is the [MASK] of France."""   )
							# We actually don't care about the result, we just want to make sure
							# it works, meaning the float16 tensor got casted back to float32
							# for postprocessing.
							self.assertIsInstance(snake_case_    ,						snake_case_   )

			@slow
			@require_torch
			def    lowerCAmelCase__						(							self			:							List[Any]   ):
							UpperCamelCase_:				str						=    pipeline(task="""fill-mask"""    ,						model="""distilroberta-base"""    ,						top_k=2    ,						framework="""pt"""   )
							self.run_large_test(snake_case_   )

			@slow
			@require_tf
			def    lowerCAmelCase__						(							self			:							Optional[int]   ):
							UpperCamelCase_:				Optional[Any]						=    pipeline(task="""fill-mask"""    ,						model="""distilroberta-base"""    ,						top_k=2    ,						framework="""tf"""   )
							self.run_large_test(snake_case_   )

			def    lowerCAmelCase__						(							self			:							Optional[Any]    ,						snake_case_			:							Union[str, Any]   ):
							UpperCamelCase_:				Dict						=    unmasker("""My name is <mask>"""   )
							self.assertEqual(
							    nested_simplify(snake_case_   )    ,						[
							        {"""sequence""": """My name is John""", """score""": 0.008, """token""": 610, """token_str""": """ John"""},
							        {"""sequence""": """My name is Chris""", """score""": 0.007, """token""": 1573, """token_str""": """ Chris"""},
							    ]    ,						)
							UpperCamelCase_:				Optional[Any]						=    unmasker("""The largest city in France is <mask>"""   )
							self.assertEqual(
							    nested_simplify(snake_case_   )    ,						[
							        {
							            """sequence""": """The largest city in France is Paris""",
							            """score""": 0.251,
							            """token""": 2201,
							            """token_str""": """ Paris""",
							        },
							        {
							            """sequence""": """The largest city in France is Lyon""",
							            """score""": 0.214,
							            """token""": 1_2790,
							            """token_str""": """ Lyon""",
							        },
							    ]    ,						)

							UpperCamelCase_:				str						=    unmasker("""My name is <mask>"""    ,						targets=[""" Patrick""", """ Clara""", """ Teven"""]    ,						top_k=3   )
							self.assertEqual(
							    nested_simplify(snake_case_   )    ,						[
							        {"""sequence""": """My name is Patrick""", """score""": 0.005, """token""": 3499, """token_str""": """ Patrick"""},
							        {"""sequence""": """My name is Clara""", """score""": 0.000, """token""": 1_3606, """token_str""": """ Clara"""},
							        {"""sequence""": """My name is Te""", """score""": 0.000, """token""": 2941, """token_str""": """ Te"""},
							    ]    ,						)

			@require_torch
			def    lowerCAmelCase__						(							self			:							List[str]   ):
							UpperCamelCase_:				List[Any]						=    pipeline(task="""fill-mask"""    ,						model="""sshleifer/tiny-distilroberta-base"""    ,						framework="""pt"""   )
							UpperCamelCase_:				int						=    None
							UpperCamelCase_:				List[str]						=    None
							self.run_pipeline_test(snake_case_    ,						[]   )

			@require_tf
			def    lowerCAmelCase__						(							self			:							Optional[Any]   ):
							UpperCamelCase_:				List[str]						=    pipeline(task="""fill-mask"""    ,						model="""sshleifer/tiny-distilroberta-base"""    ,						framework="""tf"""   )
							UpperCamelCase_:				str						=    None
							UpperCamelCase_:				Dict						=    None
							self.run_pipeline_test(snake_case_    ,						[]   )

			def    lowerCAmelCase__						(							self			:							Any    ,						snake_case_			:							Any    ,						snake_case_			:							Optional[Any]    ,						snake_case_			:							List[Any]   ):
							if tokenizer is None or tokenizer.mask_token_id is None:
											self.skipTest("""The provided tokenizer has no mask token, (probably reformer or wav2vec2)"""   )

							UpperCamelCase_:				Tuple						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_   )
							UpperCamelCase_:				Optional[Any]						=    [
							    f'''This is another {tokenizer.mask_token} test''',
							]
							return fill_masker, examples

			def    lowerCAmelCase__						(							self			:							List[Any]    ,						snake_case_			:							Union[str, Any]    ,						snake_case_			:							Union[str, Any]   ):
							UpperCamelCase_:				int						=    fill_masker.tokenizer
							UpperCamelCase_:				List[Any]						=    fill_masker.model

							UpperCamelCase_:				Optional[Any]						=    fill_masker(
							    f'''This is a {tokenizer.mask_token}'''    ,						)
							self.assertEqual(
							    snake_case_    ,						[
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							    ]    ,						)

							UpperCamelCase_:				Any						=    fill_masker([f'''This is a {tokenizer.mask_token}''']   )
							self.assertEqual(
							    snake_case_    ,						[
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							    ]    ,						)

							UpperCamelCase_:				Any						=    fill_masker([f'''This is a {tokenizer.mask_token}''', f'''Another {tokenizer.mask_token} great test.''']   )
							self.assertEqual(
							    snake_case_    ,						[
							        [
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        ],
							        [
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        ],
							    ]    ,						)

							with self.assertRaises(snake_case_   ):
											fill_masker([None]   )
							# No mask_token is not supported
							with self.assertRaises(snake_case_   ):
											fill_masker("""This is"""   )

							self.run_test_top_k(snake_case_    ,						snake_case_   )
							self.run_test_targets(snake_case_    ,						snake_case_   )
							self.run_test_top_k_targets(snake_case_    ,						snake_case_   )
							self.fill_mask_with_duplicate_targets_and_top_k(snake_case_    ,						snake_case_   )
							self.fill_mask_with_multiple_masks(snake_case_    ,						snake_case_   )

			def    lowerCAmelCase__						(							self			:							Optional[int]    ,						snake_case_			:							Tuple    ,						snake_case_			:							Optional[int]   ):
							UpperCamelCase_:				Any						=    tokenizer.get_vocab()
							UpperCamelCase_:				List[str]						=    sorted(vocab.keys()   )[:2]
							# Pipeline argument
							UpperCamelCase_:				Union[str, Any]						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_    ,						targets=snake_case_   )
							UpperCamelCase_:				Optional[int]						=    fill_masker(f'''This is a {tokenizer.mask_token}'''   )
							self.assertEqual(
							    snake_case_    ,						[
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							    ]    ,						)
							UpperCamelCase_:				int						=    {vocab[el] for el in targets}
							self.assertEqual({el["""token"""] for el in outputs}    ,						snake_case_   )
							UpperCamelCase_:				Dict						=    [tokenizer.decode([x]   ) for x in target_ids]
							self.assertEqual({el["""token_str"""] for el in outputs}    ,						set(snake_case_   )   )

							# Call argument
							UpperCamelCase_:				Union[str, Any]						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_   )
							UpperCamelCase_:				int						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						targets=snake_case_   )
							self.assertEqual(
							    snake_case_    ,						[
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							    ]    ,						)
							UpperCamelCase_:				List[Any]						=    {vocab[el] for el in targets}
							self.assertEqual({el["""token"""] for el in outputs}    ,						snake_case_   )
							UpperCamelCase_:				Tuple						=    [tokenizer.decode([x]   ) for x in target_ids]
							self.assertEqual({el["""token_str"""] for el in outputs}    ,						set(snake_case_   )   )

							# Score equivalence
							UpperCamelCase_:				str						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						targets=snake_case_   )
							UpperCamelCase_:				Optional[int]						=    [top_mask["""token_str"""] for top_mask in outputs]
							UpperCamelCase_:				Dict						=    [top_mask["""score"""] for top_mask in outputs]

							# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
							if set(snake_case_   ) == set(snake_case_   ):
											UpperCamelCase_:				Union[str, Any]						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						targets=snake_case_   )
											UpperCamelCase_:				List[str]						=    [top_mask["""score"""] for top_mask in unmasked_targets]
											self.assertEqual(nested_simplify(snake_case_   )    ,						nested_simplify(snake_case_   )   )

							# Raises with invalid
							with self.assertRaises(snake_case_   ):
											UpperCamelCase_:				List[Any]						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						targets=[]   )
							# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
							if "" not in tokenizer.get_vocab():
											with self.assertRaises(snake_case_   ):
															UpperCamelCase_:				Any						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						targets=[""""""]   )
											with self.assertRaises(snake_case_   ):
															UpperCamelCase_:				Dict						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						targets=""""""   )

			def    lowerCAmelCase__						(							self			:							List[str]    ,						snake_case_			:							List[Any]    ,						snake_case_			:							Dict   ):
							UpperCamelCase_:				int						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_    ,						top_k=2   )
							UpperCamelCase_:				List[Any]						=    fill_masker(f'''This is a {tokenizer.mask_token}'''   )
							self.assertEqual(
							    snake_case_    ,						[
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							    ]    ,						)

							UpperCamelCase_:				int						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_   )
							UpperCamelCase_:				Optional[Any]						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						top_k=2   )
							self.assertEqual(
							    snake_case_    ,						[
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							    ]    ,						)
							self.assertEqual(nested_simplify(snake_case_   )    ,						nested_simplify(snake_case_   )   )

			def    lowerCAmelCase__						(							self			:							Any    ,						snake_case_			:							str    ,						snake_case_			:							List[Any]   ):
							UpperCamelCase_:				List[str]						=    tokenizer.get_vocab()
							UpperCamelCase_:				List[Any]						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_   )

							# top_k=2, ntargets=3
							UpperCamelCase_:				List[str]						=    sorted(vocab.keys()   )[:3]
							UpperCamelCase_:				List[Any]						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						top_k=2    ,						targets=snake_case_   )

							# If we use the most probably targets, and filter differently, we should still
							# have the same results
							UpperCamelCase_:				int						=    [el["""token_str"""] for el in sorted(snake_case_    ,						key=lambda snake_case_   : x["score"]    ,						reverse=snake_case_   )]
							# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
							if set(snake_case_   ).issubset(snake_case_   ):
											UpperCamelCase_:				List[str]						=    fill_masker(f'''This is a {tokenizer.mask_token}'''    ,						top_k=3    ,						targets=snake_case_   )
											# They should yield exactly the same result
											self.assertEqual(nested_simplify(snake_case_   )    ,						nested_simplify(snake_case_   )   )

			def    lowerCAmelCase__						(							self			:							List[str]    ,						snake_case_			:							Tuple    ,						snake_case_			:							Tuple   ):
							UpperCamelCase_:				List[Any]						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_   )
							UpperCamelCase_:				Optional[int]						=    tokenizer.get_vocab()
							# String duplicates + id duplicates
							UpperCamelCase_:				Tuple						=    sorted(vocab.keys()   )[:3]
							UpperCamelCase_:				str						=    [targets[0], targets[1], targets[0], targets[2], targets[1]]
							UpperCamelCase_:				str						=    fill_masker(f'''My name is {tokenizer.mask_token}'''    ,						targets=snake_case_    ,						top_k=10   )

							# The target list contains duplicates, so we can't output more
							# than them
							self.assertEqual(len(snake_case_   )    ,						3   )




			def    lowerCAmelCase__						(							self			:							List[str]    ,						snake_case_			:							List[str]    ,						snake_case_			:							int   ):
							UpperCamelCase_:				Any						=    FillMaskPipeline(model=snake_case_    ,						tokenizer=snake_case_   )

							UpperCamelCase_:				Dict						=    fill_masker(
							    f'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''    ,						top_k=2   )
							self.assertEqual(
							    snake_case_    ,						[
							        [
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        ],
							        [
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        ],
							        [
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							            {"""sequence""": ANY(snake_case_   ), """score""": ANY(snake_case_   ), """token""": ANY(snake_case_   ), """token_str""": ANY(snake_case_   )},
							        ],
							    ]    ,						)








lowerCamelCase_    :			Tuple    =	{
    """meter""": """m""",
    """kilometer""": """km""",
    """megametre""": """Mm""",
    """gigametre""": """Gm""",
    """terametre""": """Tm""",
    """petametre""": """Pm""",
    """exametre""": """Em""",
    """zettametre""": """Zm""",
    """yottametre""": """Ym""",
}
# Exponent of the factor(meter)
lowerCamelCase_    :			Union[str, Any]    =	{
    """m""": 0,
    """km""": 3,
    """Mm""": 6,
    """Gm""": 9,
    """Tm""": 12,
    """Pm""": 15,
    """Em""": 18,
    """Zm""": 21,
    """Ym""": 24,
}







def 							A__       (    lowerCamelCase  ,     lowerCamelCase  ,     lowerCamelCase    )	->						float:
				UpperCamelCase_:				Any						=    from_type.lower().strip("""s"""    )
				UpperCamelCase_:				int						=    to_type.lower().strip("""s"""    )

				UpperCamelCase_:				Any						=    UNIT_SYMBOL.get(lowerCamelCase  ,     lowerCamelCase    )
				UpperCamelCase_:				str						=    UNIT_SYMBOL.get(lowerCamelCase  ,     lowerCamelCase    )

				if from_sanitized not in METRIC_CONVERSION:
								UpperCamelCase_:				Optional[int]						=    (
								    F'''Invalid \'from_type\' value: {from_type!r}.\n'''
								    F'''Conversion abbreviations are: {", ".join(lowerCamelCase    )}'''
								)
								raise ValueError(lowerCamelCase    )
				if to_sanitized not in METRIC_CONVERSION:
								UpperCamelCase_:				Dict						=    (
								    F'''Invalid \'to_type\' value: {to_type!r}.\n'''
								    F'''Conversion abbreviations are: {", ".join(lowerCamelCase    )}'''
								)
								raise ValueError(lowerCamelCase    )
				UpperCamelCase_:				Union[str, Any]						=    METRIC_CONVERSION[from_sanitized]
				UpperCamelCase_:				str						=    METRIC_CONVERSION[to_sanitized]
				UpperCamelCase_:				Tuple						=    1

				if from_exponent > to_exponent:
								UpperCamelCase_:				Union[str, Any]						=    from_exponent - to_exponent
				else:
								UpperCamelCase_:				Dict						=    -(to_exponent - from_exponent)

				return value * pow(10  ,     lowerCamelCase    )


if __name__ == "__main__":
							from doctest import testmod

							testmod()






