


"""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   _a      (      unittest.TestCase ):
    a_    :				Optional[int]             =    MODEL_FOR_MASKED_LM_MAPPING
    a_    :				List[Any]             =    TF_MODEL_FOR_MASKED_LM_MAPPING
    def      _UpperCamelCase       ( self							:					str				):
          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      _UpperCamelCase       ( self							:					Any				):
          lowerCamelCase__           =		pipeline(task='fill-mask'							,					model='sshleifer/tiny-distilroberta-base'							,					top_k=2							,					framework='tf'				)
          lowerCamelCase__           =		unmasker('My name is <mask>'				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__							,					decimals=6				)							,					[
                  {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 3_80_15, 'token_str': ' grouped'},
                  {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 2_55_06, 'token_str': ' accuser'},
              ]							,					)

          lowerCamelCase__           =		unmasker('The largest city in France is <mask>'				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__							,					decimals=6				)							,					[
                  {
                      'sequence': 'The largest city in France is grouped',
                      'score': 2.1e-05,
                      'token': 3_80_15,
                      'token_str': ' grouped',
                  },
                  {
                      'sequence': 'The largest city in France is accuser',
                      'score': 2.1e-05,
                      'token': 2_55_06,
                      'token_str': ' accuser',
                  },
              ]							,					)

          lowerCamelCase__           =		unmasker('My name is <mask>'							,					targets=[' Patrick', ' Clara', ' Teven']							,					top_k=3				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__							,					decimals=6				)							,					[
                  {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 1_36_06, 'token_str': ' Clara'},
                  {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 34_99, 'token_str': ' Patrick'},
                  {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 29_41, 'token_str': ' Te'},
              ]							,					)
    @require_torch
    def      _UpperCamelCase       ( self							:					Any				):
          lowerCamelCase__           =		pipeline(task='fill-mask'							,					model='sshleifer/tiny-distilroberta-base'							,					top_k=2							,					framework='pt'				)

          lowerCamelCase__           =		unmasker('My name is <mask>'				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__							,					decimals=6				)							,					[
                  {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 3_56_76, 'token_str': ' Maul'},
                  {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 1_64_16, 'token_str': 'ELS'},
              ]							,					)

          lowerCamelCase__           =		unmasker('The largest city in France is <mask>'				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__							,					decimals=6				)							,					[
                  {
                      'sequence': 'The largest city in France is Maul',
                      'score': 2.2e-05,
                      'token': 3_56_76,
                      'token_str': ' Maul',
                  },
                  {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 1_64_16, 'token_str': 'ELS'},
              ]							,					)

          lowerCamelCase__           =		unmasker('My name is <mask>'							,					targets=[' Patrick', ' Clara', ' Teven']							,					top_k=3				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__							,					decimals=6				)							,					[
                  {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 34_99, 'token_str': ' Patrick'},
                  {'sequence': 'My name is Te', 'score': 2e-05, 'token': 29_41, 'token_str': ' Te'},
                  {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 1_36_06, 'token_str': ' Clara'},
              ]							,					)

          lowerCamelCase__           =		unmasker('My name is <mask> <mask>'							,					top_k=2				)

          self.assertEqual(
              nested_simplify(UpperCAmelCase__							,					decimals=6				)							,					[
                  [
                      {
                          'score': 2.2e-05,
                          'token': 3_56_76,
                          'token_str': ' Maul',
                          'sequence': '<s>My name is Maul<mask></s>',
                      },
                      {'score': 2.2e-05, 'token': 1_64_16, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
                  ],
                  [
                      {
                          'score': 2.2e-05,
                          'token': 3_56_76,
                          'token_str': ' Maul',
                          'sequence': '<s>My name is<mask> Maul</s>',
                      },
                      {'score': 2.2e-05, 'token': 1_64_16, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
                  ],
              ]							,					)
    @require_torch_gpu
    def      _UpperCamelCase       ( self							:					Tuple				):
          lowerCamelCase__           =		pipeline('fill-mask'							,					model='hf-internal-testing/tiny-random-distilbert'							,					device=0							,					framework='pt'				)

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

          lowerCamelCase__           =		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(UpperCAmelCase__							,					UpperCAmelCase__				)
    @slow
    @require_torch
    def      _UpperCamelCase       ( self							:					Dict				):
          lowerCamelCase__           =		pipeline(task='fill-mask'							,					model='distilroberta-base'							,					top_k=2							,					framework='pt'				)
          self.run_large_test(UpperCAmelCase__				)
    @slow
    @require_tf
    def      _UpperCamelCase       ( self							:					Optional[Any]				):
          lowerCamelCase__           =		pipeline(task='fill-mask'							,					model='distilroberta-base'							,					top_k=2							,					framework='tf'				)
          self.run_large_test(UpperCAmelCase__				)
    def      _UpperCamelCase       ( self							:					Dict							,					SCREAMING_SNAKE_CASE__							:					Dict				):
          lowerCamelCase__           =		unmasker('My name is <mask>'				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__				)							,					[
                  {'sequence': 'My name is John', 'score': 0.0_08, 'token': 6_10, 'token_str': ' John'},
                  {'sequence': 'My name is Chris', 'score': 0.0_07, 'token': 15_73, 'token_str': ' Chris'},
              ]							,					)
          lowerCamelCase__           =		unmasker('The largest city in France is <mask>'				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__				)							,					[
                  {
                      'sequence': 'The largest city in France is Paris',
                      'score': 0.2_51,
                      'token': 22_01,
                      'token_str': ' Paris',
                  },
                  {
                      'sequence': 'The largest city in France is Lyon',
                      'score': 0.2_14,
                      'token': 1_27_90,
                      'token_str': ' Lyon',
                  },
              ]							,					)

          lowerCamelCase__           =		unmasker('My name is <mask>'							,					targets=[' Patrick', ' Clara', ' Teven']							,					top_k=3				)
          self.assertEqual(
              nested_simplify(UpperCAmelCase__				)							,					[
                  {'sequence': 'My name is Patrick', 'score': 0.0_05, 'token': 34_99, 'token_str': ' Patrick'},
                  {'sequence': 'My name is Clara', 'score': 0.0_00, 'token': 1_36_06, 'token_str': ' Clara'},
                  {'sequence': 'My name is Te', 'score': 0.0_00, 'token': 29_41, 'token_str': ' Te'},
              ]							,					)
    @require_torch
    def      _UpperCamelCase       ( self							:					Any				):
          lowerCamelCase__           =		pipeline(task='fill-mask'							,					model='sshleifer/tiny-distilroberta-base'							,					framework='pt'				)
          lowerCamelCase__           =		None
          lowerCamelCase__           =		None
          self.run_pipeline_test(UpperCAmelCase__							,					[]				)
    @require_tf
    def      _UpperCamelCase       ( self							:					Dict				):
          lowerCamelCase__           =		pipeline(task='fill-mask'							,					model='sshleifer/tiny-distilroberta-base'							,					framework='tf'				)
          lowerCamelCase__           =		None
          lowerCamelCase__           =		None
          self.run_pipeline_test(UpperCAmelCase__							,					[]				)
    def      _UpperCamelCase       ( self							:					int							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Dict							,					SCREAMING_SNAKE_CASE__							:					Optional[int]				):
          if tokenizer is None or tokenizer.mask_token_id is None:
                self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)'				)

          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__				)
          lowerCamelCase__           =		[
              F'This is another {tokenizer.mask_token} test',
          ]
          return fill_masker, examples
    def      _UpperCamelCase       ( self							:					int							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]				):
          lowerCamelCase__           =		fill_masker.tokenizer
          lowerCamelCase__           =		fill_masker.model

          lowerCamelCase__           =		fill_masker(
              F'This is a {tokenizer.mask_token}'							,					)
          self.assertEqual(
              UpperCAmelCase__							,					[
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
              ]							,					)

          lowerCamelCase__           =		fill_masker([F'This is a {tokenizer.mask_token}']				)
          self.assertEqual(
              UpperCAmelCase__							,					[
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
              ]							,					)

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

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

          self.run_test_top_k(UpperCAmelCase__							,					UpperCAmelCase__				)
          self.run_test_targets(UpperCAmelCase__							,					UpperCAmelCase__				)
          self.run_test_top_k_targets(UpperCAmelCase__							,					UpperCAmelCase__				)
          self.fill_mask_with_duplicate_targets_and_top_k(UpperCAmelCase__							,					UpperCAmelCase__				)
          self.fill_mask_with_multiple_masks(UpperCAmelCase__							,					UpperCAmelCase__				)
    def      _UpperCamelCase       ( self							:					str							,					SCREAMING_SNAKE_CASE__							:					Any							,					SCREAMING_SNAKE_CASE__							:					int				):
          lowerCamelCase__           =		tokenizer.get_vocab()
          lowerCamelCase__           =		sorted(vocab.keys()				)[:2]
          # Pipeline argument
          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__							,					targets=UpperCAmelCase__				)
          lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'				)
          self.assertEqual(
              UpperCAmelCase__							,					[
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
              ]							,					)
          lowerCamelCase__           =		{vocab[el] for el in targets}
          self.assertEqual({el['token'] for el in outputs}							,					UpperCAmelCase__				)
          lowerCamelCase__           =		[tokenizer.decode([x]				) for x in target_ids]
          self.assertEqual({el['token_str'] for el in outputs}							,					set(UpperCAmelCase__				)				)

          # Call argument
          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__				)
          lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'							,					targets=UpperCAmelCase__				)
          self.assertEqual(
              UpperCAmelCase__							,					[
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
              ]							,					)
          lowerCamelCase__           =		{vocab[el] for el in targets}
          self.assertEqual({el['token'] for el in outputs}							,					UpperCAmelCase__				)
          lowerCamelCase__           =		[tokenizer.decode([x]				) for x in target_ids]
          self.assertEqual({el['token_str'] for el in outputs}							,					set(UpperCAmelCase__				)				)

          # Score equivalence
          lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'							,					targets=UpperCAmelCase__				)
          lowerCamelCase__           =		[top_mask['''token_str'''] for top_mask in outputs]
          lowerCamelCase__           =		[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(UpperCAmelCase__				) == set(UpperCAmelCase__				):
                lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'							,					targets=UpperCAmelCase__				)
                lowerCamelCase__           =		[top_mask['''score'''] for top_mask in unmasked_targets]
                self.assertEqual(nested_simplify(UpperCAmelCase__				)							,					nested_simplify(UpperCAmelCase__				)				)

          # Raises with invalid
          with self.assertRaises(UpperCAmelCase__				):
                lowerCamelCase__           =		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(UpperCAmelCase__				):
                      lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'							,					targets=['']				)
                with self.assertRaises(UpperCAmelCase__				):
                      lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'							,					targets=''				)
    def      _UpperCamelCase       ( self							:					int							,					SCREAMING_SNAKE_CASE__							:					str							,					SCREAMING_SNAKE_CASE__							:					Optional[int]				):
          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__							,					top_k=2				)
          lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'				)
          self.assertEqual(
              UpperCAmelCase__							,					[
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
              ]							,					)

          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__				)
          lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'							,					top_k=2				)
          self.assertEqual(
              UpperCAmelCase__							,					[
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
                  {'sequence': ANY(UpperCAmelCase__				), 'score': ANY(UpperCAmelCase__				), 'token': ANY(UpperCAmelCase__				), 'token_str': ANY(UpperCAmelCase__				)},
              ]							,					)
          self.assertEqual(nested_simplify(UpperCAmelCase__				)							,					nested_simplify(UpperCAmelCase__				)				)
    def      _UpperCamelCase       ( self							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					Dict							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]				):
          lowerCamelCase__           =		tokenizer.get_vocab()
          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__				)

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

          # If we use the most probably targets, and filter differently, we should still
          # have the same results
          lowerCamelCase__           =		[el['''token_str'''] for el in sorted(UpperCAmelCase__							,					key=lambda SCREAMING_SNAKE_CASE__				: x["score"]							,					reverse=UpperCAmelCase__				)]
          # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
          if set(UpperCAmelCase__				).issubset(UpperCAmelCase__				):
                lowerCamelCase__           =		fill_masker(F'This is a {tokenizer.mask_token}'							,					top_k=3							,					targets=UpperCAmelCase__				)
                # They should yield exactly the same result
                self.assertEqual(nested_simplify(UpperCAmelCase__				)							,					nested_simplify(UpperCAmelCase__				)				)
    def      _UpperCamelCase       ( self							:					Tuple							,					SCREAMING_SNAKE_CASE__							:					List[Any]							,					SCREAMING_SNAKE_CASE__							:					Any				):
          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__				)
          lowerCamelCase__           =		tokenizer.get_vocab()
          # String duplicates + id duplicates
          lowerCamelCase__           =		sorted(vocab.keys()				)[:3]
          lowerCamelCase__           =		[targets[0], targets[1], targets[0], targets[2], targets[1]]
          lowerCamelCase__           =		fill_masker(F'My name is {tokenizer.mask_token}'							,					targets=UpperCAmelCase__							,					top_k=10				)

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


    def      _UpperCamelCase       ( self							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Tuple							,					SCREAMING_SNAKE_CASE__							:					Optional[int]				):
          lowerCamelCase__           =		FillMaskPipeline(model=UpperCAmelCase__							,					tokenizer=UpperCAmelCase__				)

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







"""simple docstring"""


def   snake_case						(				_a:     int		,   _a:     list[int]		,   _a:     int							)->		int:
      '''simple docstring'''


      def count_of_possible_combinations(_a:     int							) -> int:
            if target < 0:
                  return 0
            if target == 0:
                  return 1
            return sum(count_of_possible_combinations(target - item							) for item in array							)

      return count_of_possible_combinations(_a							)



def   snake_case						(				_a:     int		,   _a:     list[int]		,   _a:     int							)->		int:
      '''simple docstring'''


      def count_of_possible_combinations_with_dp_array(
          _a:     int		,   _a:     list[int]							) -> int:
            if target < 0:
                  return 0
            if target == 0:
                  return 1
            if dp_array[target] != -1:
                  return dp_array[target]
            lowerCamelCase__           =		sum(
                count_of_possible_combinations_with_dp_array(target - item		,   _a							)
                for item in array							)
            lowerCamelCase__           =		answer
            return answer

      lowerCamelCase__           =		[-1] * (target + 1)
      return count_of_possible_combinations_with_dp_array(_a		,   _a							)



def   snake_case						(				_a:     int		,   _a:     list[int]		,   _a:     int							)->		int:
      '''simple docstring'''


      lowerCamelCase__           =		[0] * (target + 1)
      lowerCamelCase__           =		1

      for i in range(1		,   target + 1							):
            for j in range(_a							):
                  if i - array[j] >= 0:
                        dp_array[i] += dp_array[i - array[j]]

      return dp_array[target]


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   _snake_case          =							3
   _snake_case          =							5
   _snake_case          =							[1, 2, 5]
   print(combination_sum_iv(n, array, target))



