




'''simple docstring'''



import argparse
import glob
import importlib.util
import os
import re

import black
from doc_builder.style_doc import style_docstrings_in_code


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_copies.py
UpperCAmelCase_							:	Any	     =		'src/diffusers'
UpperCAmelCase_							:	Dict	     =		'.'


# This is to make sure the diffusers module imported is the one in the repo.
UpperCAmelCase_							:	Union[str, Any]	     =		importlib.util.spec_from_file_location(
    '''diffusers''',
    os.path.join(DIFFUSERS_PATH, '''__init__.py'''),
    submodule_search_locations=[DIFFUSERS_PATH],
)
UpperCAmelCase_							:	Union[str, Any]	     =		spec.loader.load_module()







def       _UpperCamelCase			(_lowerCamelCase				:  Tuple ,						_lowerCamelCase				:  Optional[Any]						)-> Optional[int]:




     '''simple docstring'''





     return line.startswith(_lowerCAmelCase						) or len(_lowerCAmelCase						) <= 1 or re.search(R'''^\s*\)(\s*->.*:|:)\s*$''' ,						_lowerCAmelCase						) is not None







def       _UpperCamelCase			(_lowerCamelCase				:  Optional[Any]						)-> List[str]:




     '''simple docstring'''





     __snake_case            =	object_name.split('''.'''						)
     __snake_case            =	0

     # First let's find the module where our object lives.
     __snake_case            =	parts[i]
     while i < len(_lowerCAmelCase						) and not os.path.isfile(os.path.join(_lowerCAmelCase ,						f'''{module}.py'''						)						):
          i += 1
          if i < len(_lowerCAmelCase						):
               __snake_case            =	os.path.join(_lowerCAmelCase ,						parts[i]						)
     if i >= len(_lowerCAmelCase						):
          raise ValueError(f'''`object_name` should begin with the name of a module of diffusers but got {object_name}.'''						)

     with open(os.path.join(_lowerCAmelCase ,						f'''{module}.py'''						) ,						'''r''' ,						encoding='''utf-8''' ,						newline='''\n'''						) as f:
          __snake_case            =	f.readlines()

     # Now let's find the class / func in the code!
     __snake_case            =	''''''
     __snake_case            =	0
     for name in parts[i + 1 :]:
          while (
              line_index < len(_lowerCAmelCase						) and re.search(Rf'''^{indent}(class|def)\s+{name}(\(|\:)''' ,						lines[line_index]						) is None
          ):
               line_index += 1
          indent += "    "
          line_index += 1

     if line_index >= len(_lowerCAmelCase						):
          raise ValueError(f''' {object_name} does not match any function or class in {module}.'''						)

     # We found the beginning of the class / func, now let's find the end (when the indent diminishes).
     __snake_case            =	line_index
     while line_index < len(_lowerCAmelCase						) and _should_continue(lines[line_index] ,						_lowerCAmelCase						):
          line_index += 1
     # Clean up empty lines at the end (if any).
     while len(lines[line_index - 1]						) <= 1:
          line_index -= 1

     __snake_case            =	lines[start_index:line_index]
     return "".join(_lowerCAmelCase						)


UpperCAmelCase_							:	Union[str, Any]	     =		re.compile(R'''^(\s*)#\s*Copied from\s+diffusers\.(\S+\.\S+)\s*($|\S.*$)''')
UpperCAmelCase_							:	Optional[Any]	     =		re.compile(R'''^\s*(\S+)->(\S+)(\s+.*|$)''')
UpperCAmelCase_							:	Tuple	     =		re.compile(R'''<FILL\s+[^>]*>''')







def       _UpperCamelCase			(_lowerCamelCase				:  Optional[Any]						)-> str:




     '''simple docstring'''





     __snake_case            =	code.split('''\n'''						)
     __snake_case            =	0
     while idx < len(_lowerCAmelCase						) and len(lines[idx]						) == 0:
          idx += 1
     if idx < len(_lowerCAmelCase						):
          return re.search(R'''^(\s*)\S''' ,						lines[idx]						).groups()[0]
     return ""







def       _UpperCamelCase			(_lowerCamelCase				:  int						)-> Union[str, Any]:




     '''simple docstring'''





     __snake_case            =	len(get_indent(_lowerCAmelCase						)						) > 0
     if has_indent:
          __snake_case            =	f'''class Bla:\n{code}'''
     __snake_case            =	black.Mode(target_versions={black.TargetVersion.PYaa} ,						line_length=1_19 ,						preview=_lowerCAmelCase						)
     __snake_case            =	black.format_str(_lowerCAmelCase ,						mode=_lowerCAmelCase						)
     __snake_case       ,     __snake_case            =	style_docstrings_in_code(_lowerCAmelCase						)
     return result[len('''class Bla:\n'''						) :] if has_indent else result







def       _UpperCamelCase			(_lowerCamelCase				:  int ,						_lowerCamelCase				:  Tuple=False						)-> Optional[int]:




     '''simple docstring'''





     with open(_lowerCAmelCase ,						'''r''' ,						encoding='''utf-8''' ,						newline='''\n'''						) as f:
          __snake_case            =	f.readlines()
     __snake_case            =	[]
     __snake_case            =	0
     # Not a for loop cause `lines` is going to change (if `overwrite=True`).
     while line_index < len(_lowerCAmelCase						):
          __snake_case            =	_re_copy_warning.search(lines[line_index]						)
          if search is None:
               line_index += 1
               continue

          # There is some copied code here, let's retrieve the original.
          __snake_case       ,     __snake_case       ,     __snake_case            =	search.groups()
          __snake_case            =	find_code_in_diffusers(_lowerCAmelCase						)
          __snake_case            =	get_indent(_lowerCAmelCase						)

          __snake_case            =	line_index + 1 if indent == theoretical_indent else line_index + 2
          __snake_case            =	theoretical_indent
          __snake_case            =	start_index

          # Loop to check the observed code, stop when indentation diminishes or if we see a End copy comment.
          __snake_case            =	True
          while line_index < len(_lowerCAmelCase						) and should_continue:
               line_index += 1
               if line_index >= len(_lowerCAmelCase						):
                    break
               __snake_case            =	lines[line_index]
               __snake_case            =	_should_continue(_lowerCAmelCase ,						_lowerCAmelCase						) and re.search(f'''^{indent}# End copy''' ,						_lowerCAmelCase						) is None
          # Clean up empty lines at the end (if any).
          while len(lines[line_index - 1]						) <= 1:
               line_index -= 1

          __snake_case            =	lines[start_index:line_index]
          __snake_case            =	''''''.join(_lowerCAmelCase						)

          # Remove any nested `Copied from` comments to avoid circular copies
          __snake_case            =	[line for line in theoretical_code.split('''\n'''						) if _re_copy_warning.search(_lowerCAmelCase						) is None]
          __snake_case            =	'''\n'''.join(_lowerCAmelCase						)

          # Before comparing, use the `replace_pattern` on the original code.
          if len(_lowerCAmelCase						) > 0:
               __snake_case            =	replace_pattern.replace('''with''' ,						''''''						).split(''','''						)
               __snake_case            =	[_re_replace_pattern.search(_lowerCAmelCase						) for p in patterns]
               for pattern in patterns:
                    if pattern is None:
                         continue
                    __snake_case       ,     __snake_case       ,     __snake_case            =	pattern.groups()
                    __snake_case            =	re.sub(_lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase						)
                    if option.strip() == "all-casing":
                         __snake_case            =	re.sub(obja.lower() ,						obja.lower() ,						_lowerCAmelCase						)
                         __snake_case            =	re.sub(obja.upper() ,						obja.upper() ,						_lowerCAmelCase						)

            # Blackify after replacement. To be able to do that, we need the header (class or function definition)
            # from the previous line
               __snake_case            =	blackify(lines[start_index - 1] + theoretical_code						)
               __snake_case            =	theoretical_code[len(lines[start_index - 1]						) :]

          # Test for a diff and act accordingly.
          if observed_code != theoretical_code:
               diffs.append([object_name, start_index]						)
               if overwrite:
                    __snake_case            =	lines[:start_index] + [theoretical_code] + lines[line_index:]
                    __snake_case            =	start_index + 1

     if overwrite and len(_lowerCAmelCase						) > 0:
          # Warn the user a file has been modified.
          print(f'''Detected changes, rewriting {filename}.'''						)
          with open(_lowerCAmelCase ,						'''w''' ,						encoding='''utf-8''' ,						newline='''\n'''						) as f:
               f.writelines(_lowerCAmelCase						)
     return diffs







def       _UpperCamelCase			(_lowerCamelCase				:  int = False						)-> List[Any]:




     '''simple docstring'''





     __snake_case            =	glob.glob(os.path.join(_lowerCAmelCase ,						'''**/*.py'''						) ,						recursive=_lowerCAmelCase						)
     __snake_case            =	[]
     for filename in all_files:
          __snake_case            =	is_copy_consistent(_lowerCAmelCase ,						_lowerCAmelCase						)
          diffs += [f'''- {filename}: copy does not match {d[0]} at line {d[1]}''' for d in new_diffs]
     if not overwrite and len(_lowerCAmelCase						) > 0:
          __snake_case            =	'''\n'''.join(_lowerCAmelCase						)
          raise Exception(
              '''Found the following copy inconsistencies:\n'''
              + diff
              + '''\nRun `make fix-copies` or `python utils/check_copies.py --fix_and_overwrite` to fix them.'''						)


if __name__ == "__main__":
     UpperCAmelCase_							:	str	     =		argparse.ArgumentParser()
     parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
     UpperCAmelCase_							:	Union[str, Any]	     =		parser.parse_args()

     check_copies(args.fix_and_overwrite)










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 ):
					snake_case_		:					int    					=						MODEL_FOR_MASKED_LM_MAPPING
					snake_case_		:					Optional[int]    					=						TF_MODEL_FOR_MASKED_LM_MAPPING


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						Union[str, Any]:




											'''simple docstring'''

											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 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is grouped", "score": 2.1e-0_5, "token": 3_8_0_1_5, "token_str": " grouped"},
											        {"sequence": "My name is accuser", "score": 2.1e-0_5, "token": 2_5_5_0_6, "token_str": " accuser"},
											    ]  ,     )

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

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is Clara", "score": 2e-0_5, "token": 1_3_6_0_6, "token_str": " Clara"},
											        {"sequence": "My name is Patrick", "score": 2e-0_5, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 1.9e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											    ]  ,     )


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     top_k=2  ,     framework="pt"    )

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

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

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE  ,     decimals=6    )  ,     [
											        {"sequence": "My name is Patrick", "score": 2.1e-0_5, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Te", "score": 2e-0_5, "token": 2_9_4_1, "token_str": " Te"},
											        {"sequence": "My name is Clara", "score": 2e-0_5, "token": 1_3_6_0_6, "token_str": " Clara"},
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask> <mask>"  ,     top_k=2    )

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


					@require_torch_gpu
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		pipeline("fill-mask"  ,     model="hf-internal-testing/tiny-random-distilbert"  ,     device=0  ,     framework="pt"    )

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

											__snake_case				=		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(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )


					@slow
					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						Tuple:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="distilroberta-base"  ,     top_k=2  ,     framework="pt"    )
											self.run_large_test(SCREAMING_SNAKE_CASE    )


					@slow
					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						int:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="distilroberta-base"  ,     top_k=2  ,     framework="tf"    )
											self.run_large_test(SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]    )      ->						str:




											'''simple docstring'''

											__snake_case				=		unmasker("My name is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {"sequence": "My name is John", "score": 0.008, "token": 6_1_0, "token_str": " John"},
											        {"sequence": "My name is Chris", "score": 0.007, "token": 1_5_7_3, "token_str": " Chris"},
											    ]  ,     )
											__snake_case				=		unmasker("The largest city in France is <mask>"    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {
											            "sequence": "The largest city in France is Paris",
											            "score": 0.251,
											            "token": 2_2_0_1,
											            "token_str": " Paris",
											        },
											        {
											            "sequence": "The largest city in France is Lyon",
											            "score": 0.214,
											            "token": 1_2_7_9_0,
											            "token_str": " Lyon",
											        },
											    ]  ,     )

											__snake_case				=		unmasker("My name is <mask>"  ,     targets=[" Patrick", " Clara", " Teven"]  ,     top_k=3    )
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE    )  ,     [
											        {"sequence": "My name is Patrick", "score": 0.005, "token": 3_4_9_9, "token_str": " Patrick"},
											        {"sequence": "My name is Clara", "score": 0.000, "token": 1_3_6_0_6, "token_str": " Clara"},
											        {"sequence": "My name is Te", "score": 0.000, "token": 2_9_4_1, "token_str": " Te"},
											    ]  ,     )


					@require_torch
					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						str:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="pt"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					@require_tf
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						Optional[int]:




											'''simple docstring'''

											__snake_case				=		pipeline(task="fill-mask"  ,     model="sshleifer/tiny-distilroberta-base"  ,     framework="tf"    )
											__snake_case				=		None
											__snake_case				=		None
											self.run_pipeline_test(SCREAMING_SNAKE_CASE  ,     []    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     SCREAMING_SNAKE_CASE						:		Any  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		Tuple    )      ->						int:




											'''simple docstring'''

											if tokenizer is None or tokenizer.mask_token_id is None:
																	self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)"    )

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		[
											    f'''This is another {tokenizer.mask_token} test''',
											]
											return fill_masker, examples


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     SCREAMING_SNAKE_CASE						:		int  ,     SCREAMING_SNAKE_CASE						:		int    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		fill_masker.tokenizer
											__snake_case				=		fill_masker.model

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

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

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

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

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


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]    )      ->						Any:




											'''simple docstring'''

											__snake_case				=		tokenizer.get_vocab()
											__snake_case				=		sorted(vocab.keys()    )[:2]
											# Pipeline argument
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE  ,     targets=SCREAMING_SNAKE_CASE    )
											__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''    )
											self.assertEqual(
											    SCREAMING_SNAKE_CASE  ,     [
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											        {"sequence": ANY(SCREAMING_SNAKE_CASE    ), "score": ANY(SCREAMING_SNAKE_CASE    ), "token": ANY(SCREAMING_SNAKE_CASE    ), "token_str": ANY(SCREAMING_SNAKE_CASE    )},
											    ]  ,     )
											__snake_case				=		{vocab[el] for el in targets}
											self.assertEqual({el["token"] for el in outputs}  ,     SCREAMING_SNAKE_CASE    )
											__snake_case				=		[tokenizer.decode([x]    ) for x in target_ids]
											self.assertEqual({el["token_str"] for el in outputs}  ,     set(SCREAMING_SNAKE_CASE    )    )

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

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

											# Raises with invalid
											with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																	__snake_case				=		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(SCREAMING_SNAKE_CASE    ):
																							__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=[""]    )
																	with self.assertRaises(SCREAMING_SNAKE_CASE    ):
																							__snake_case				=		fill_masker(f'''This is a {tokenizer.mask_token}'''  ,     targets=""    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Union[str, Any]  ,     SCREAMING_SNAKE_CASE						:		List[str]    )      ->						Optional[Any]:




											'''simple docstring'''

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

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


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]  ,     SCREAMING_SNAKE_CASE						:		str  ,     SCREAMING_SNAKE_CASE						:		List[Any]    )      ->						Dict:




											'''simple docstring'''

											__snake_case				=		tokenizer.get_vocab()
											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

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

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


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		Dict  ,     SCREAMING_SNAKE_CASE						:		Dict    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )
											__snake_case				=		tokenizer.get_vocab()
											# String duplicates + id duplicates
											__snake_case				=		sorted(vocab.keys()    )[:3]
											__snake_case				=		[targets[0], targets[1], targets[0], targets[2], targets[1]]
											__snake_case				=		fill_masker(f'''My name is {tokenizer.mask_token}'''  ,     targets=SCREAMING_SNAKE_CASE  ,     top_k=1_0    )

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






					def 				SCREAMING_SNAKE_CASE_	(    self						:		str  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		str    )      ->						Optional[Any]:




											'''simple docstring'''

											__snake_case				=		FillMaskPipeline(model=SCREAMING_SNAKE_CASE  ,     tokenizer=SCREAMING_SNAKE_CASE    )

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





