


'''simple docstring'''



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 		_snake_case					(     unittest.TestCase	):
					lowerCAmelCase      :Dict   =					MODEL_FOR_MASKED_LM_MAPPING
					lowerCAmelCase      :List[str]   =					TF_MODEL_FOR_MASKED_LM_MAPPING




					def 				snake_case__						(      self):
								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 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =     pipeline(task="""fill-mask"""							,							model="""sshleifer/tiny-distilroberta-base"""							,							top_k=2							,							framework="""tf""")
								UpperCAmelCase__  :					Dict        =     unmasker("""My name is <mask>""")
								self.assertEqual(
								    nested_simplify(_lowerCamelCase							,							decimals=6)							,							[
								        {"""sequence""": """My name is grouped""", """score""": 2.1e-0_5, """token""": 3_8015, """token_str""": """ grouped"""},
								        {"""sequence""": """My name is accuser""", """score""": 2.1e-0_5, """token""": 2_5506, """token_str""": """ accuser"""},
								    ]							,							)

								UpperCAmelCase__  :					int        =     unmasker("""The largest city in France is <mask>""")
								self.assertEqual(
								    nested_simplify(_lowerCamelCase							,							decimals=6)							,							[
								        {
								            """sequence""": """The largest city in France is grouped""",
								            """score""": 2.1e-0_5,
								            """token""": 3_8015,
								            """token_str""": """ grouped""",
								        },
								        {
								            """sequence""": """The largest city in France is accuser""",
								            """score""": 2.1e-0_5,
								            """token""": 2_5506,
								            """token_str""": """ accuser""",
								        },
								    ]							,							)

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




					@require_torch
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Tuple        =     pipeline(task="""fill-mask"""							,							model="""sshleifer/tiny-distilroberta-base"""							,							top_k=2							,							framework="""pt""")

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

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

								UpperCAmelCase__  :					Tuple        =     unmasker("""My name is <mask>"""							,							targets=[""" Patrick""", """ Clara""", """ Teven"""]							,							top_k=3)
								self.assertEqual(
								    nested_simplify(_lowerCamelCase							,							decimals=6)							,							[
								        {"""sequence""": """My name is Patrick""", """score""": 2.1e-0_5, """token""": 3499, """token_str""": """ Patrick"""},
								        {"""sequence""": """My name is Te""", """score""": 2e-0_5, """token""": 2941, """token_str""": """ Te"""},
								        {"""sequence""": """My name is Clara""", """score""": 2e-0_5, """token""": 1_3606, """token_str""": """ Clara"""},
								    ]							,							)

								UpperCAmelCase__  :					Any        =     unmasker("""My name is <mask> <mask>"""							,							top_k=2)

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




					@require_torch_gpu
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Union[str, Any]        =     pipeline("""fill-mask"""							,							model="""hf-internal-testing/tiny-random-distilbert"""							,							device=0							,							framework="""pt""")

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

								UpperCAmelCase__  :					Tuple        =     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(_lowerCamelCase							,							_lowerCamelCase)




					@slow
					@require_torch
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					int        =     pipeline(task="""fill-mask"""							,							model="""distilroberta-base"""							,							top_k=2							,							framework="""pt""")
								self.run_large_test(_lowerCamelCase)




					@slow
					@require_tf
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =     pipeline(task="""fill-mask"""							,							model="""distilroberta-base"""							,							top_k=2							,							framework="""tf""")
								self.run_large_test(_lowerCamelCase)




					def 				snake_case__						(      self							,							_lowerCamelCase):
								UpperCAmelCase__  :					List[str]        =     unmasker("""My name is <mask>""")
								self.assertEqual(
								    nested_simplify(_lowerCamelCase)							,							[
								        {"""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__  :					Dict        =     unmasker("""The largest city in France is <mask>""")
								self.assertEqual(
								    nested_simplify(_lowerCamelCase)							,							[
								        {
								            """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__  :					Tuple        =     unmasker("""My name is <mask>"""							,							targets=[""" Patrick""", """ Clara""", """ Teven"""]							,							top_k=3)
								self.assertEqual(
								    nested_simplify(_lowerCamelCase)							,							[
								        {"""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 				snake_case__						(      self):
								UpperCAmelCase__  :					str        =     pipeline(task="""fill-mask"""							,							model="""sshleifer/tiny-distilroberta-base"""							,							framework="""pt""")
								UpperCAmelCase__  :					List[str]        =     None
								UpperCAmelCase__  :					List[str]        =     None
								self.run_pipeline_test(_lowerCamelCase							,							[])




					@require_tf
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					List[str]        =     pipeline(task="""fill-mask"""							,							model="""sshleifer/tiny-distilroberta-base"""							,							framework="""tf""")
								UpperCAmelCase__  :					List[str]        =     None
								UpperCAmelCase__  :					Tuple        =     None
								self.run_pipeline_test(_lowerCamelCase							,							[])




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								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__  :					List[str]        =     FillMaskPipeline(model=_lowerCamelCase							,							tokenizer=_lowerCamelCase)
								UpperCAmelCase__  :					Tuple        =     [
								    f'''This is another {tokenizer.mask_token} test''',
								]
								return fill_masker, examples




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					str        =     fill_masker.tokenizer
								UpperCAmelCase__  :					str        =     fill_masker.model

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

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

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

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

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




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

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

								# Score equivalence
								UpperCAmelCase__  :					Dict        =     fill_masker(f'''This is a {tokenizer.mask_token}'''							,							targets=_lowerCamelCase)
								UpperCAmelCase__  :					List[str]        =     [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(_lowerCamelCase) == set(_lowerCamelCase):
											UpperCAmelCase__  :					Tuple        =     fill_masker(f'''This is a {tokenizer.mask_token}'''							,							targets=_lowerCamelCase)
											UpperCAmelCase__  :					Dict        =     [top_mask["""score"""] for top_mask in unmasked_targets]
											self.assertEqual(nested_simplify(_lowerCamelCase)							,							nested_simplify(_lowerCamelCase))

								# Raises with invalid
								with self.assertRaises(_lowerCamelCase):
											UpperCAmelCase__  :					Optional[int]        =     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(_lowerCamelCase):
														UpperCAmelCase__  :					Union[str, Any]        =     fill_masker(f'''This is a {tokenizer.mask_token}'''							,							targets=[""""""])
											with self.assertRaises(_lowerCamelCase):
														UpperCAmelCase__  :					Dict        =     fill_masker(f'''This is a {tokenizer.mask_token}'''							,							targets="""""")




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Union[str, Any]        =     FillMaskPipeline(model=_lowerCamelCase							,							tokenizer=_lowerCamelCase							,							top_k=2)
								UpperCAmelCase__  :					Union[str, Any]        =     fill_masker(f'''This is a {tokenizer.mask_token}''')
								self.assertEqual(
								    _lowerCamelCase							,							[
								        {"""sequence""": ANY(_lowerCamelCase), """score""": ANY(_lowerCamelCase), """token""": ANY(_lowerCamelCase), """token_str""": ANY(_lowerCamelCase)},
								        {"""sequence""": ANY(_lowerCamelCase), """score""": ANY(_lowerCamelCase), """token""": ANY(_lowerCamelCase), """token_str""": ANY(_lowerCamelCase)},
								    ]							,							)

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




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Optional[Any]        =     tokenizer.get_vocab()
								UpperCAmelCase__  :					str        =     FillMaskPipeline(model=_lowerCamelCase							,							tokenizer=_lowerCamelCase)

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

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




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

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




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					List[str]        =     FillMaskPipeline(model=_lowerCamelCase							,							tokenizer=_lowerCamelCase)

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



'''simple docstring'''



from itertools import permutations







def     _UpperCamelCase      (		UpperCamelCase__					):
			if num[3] % 2 != 0:
						return False

			if (num[2] + num[3] + num[4]) % 3 != 0:
						return False

			if num[5] % 5 != 0:
						return False

			UpperCAmelCase__  :					Optional[int]        =     [7, 1_1, 1_3, 1_7]
			for i, test in enumerate(UpperCamelCase__					):
						if (num[i + 4] * 1_0_0 + num[i + 5] * 1_0 + num[i + 6]) % test != 0:
									return False
			return True







def     _UpperCamelCase      (		UpperCamelCase__ = 1_0					):
			return sum(
			    int("""""".join(map(UpperCamelCase__ ,      UpperCamelCase__					)					)					)
			    for num in permutations(range(UpperCamelCase__					)					)
			    if is_substring_divisible(UpperCamelCase__					)					)


if __name__ == "__main__":
		print(f"""{solution() = }""")