




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        lowerCamelCase_							(      unittest.TestCase					):


 '''simple docstring'''







 lowercase_				    =    MODEL_FOR_MASKED_LM_MAPPING
 lowercase_				    =    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  :		List[Any]						):
       SCREAMING_SNAKE_CASE_							=			pipeline(task='fill-mask'				,				model='sshleifer/tiny-distilroberta-base'				,				top_k=2				,				framework='tf'						)
       SCREAMING_SNAKE_CASE_							=			unmasker('My name is <mask>'						)
       self.assertEqual(
           nested_simplify(_lowerCAmelCase				,				decimals=6						)				,				[
               {'sequence': 'My name is grouped', 'score': 2.1E-05, 'token': 38_015, 'token_str': ' grouped'},
               {'sequence': 'My name is accuser', 'score': 2.1E-05, 'token': 25_506, 'token_str': ' accuser'},
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			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-05,
                   'token': 38_015,
                   'token_str': ' grouped',
               },
               {
                   'sequence': 'The largest city in France is accuser',
                   'score': 2.1E-05,
                   'token': 25_506,
                   'token_str': ' accuser',
               },
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			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-05, 'token': 13_606, 'token_str': ' Clara'},
               {'sequence': 'My name is Patrick', 'score': 2E-05, 'token': 3_499, 'token_str': ' Patrick'},
               {'sequence': 'My name is Te', 'score': 1.9E-05, 'token': 2_941, 'token_str': ' Te'},
           ]				,				)



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

       SCREAMING_SNAKE_CASE_							=			unmasker('My name is <mask>'						)
       self.assertEqual(
           nested_simplify(_lowerCAmelCase				,				decimals=6						)				,				[
               {'sequence': 'My name is Maul', 'score': 2.2E-05, 'token': 35_676, 'token_str': ' Maul'},
               {'sequence': 'My name isELS', 'score': 2.2E-05, 'token': 16_416, 'token_str': 'ELS'},
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			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-05,
                   'token': 35_676,
                   'token_str': ' Maul',
               },
               {'sequence': 'The largest city in France isELS', 'score': 2.2E-05, 'token': 16_416, 'token_str': 'ELS'},
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			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-05, 'token': 3_499, 'token_str': ' Patrick'},
               {'sequence': 'My name is Te', 'score': 2E-05, 'token': 2_941, 'token_str': ' Te'},
               {'sequence': 'My name is Clara', 'score': 2E-05, 'token': 13_606, 'token_str': ' Clara'},
           ]				,				)

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

       self.assertEqual(
           nested_simplify(_lowerCAmelCase				,				decimals=6						)				,				[
               [
                   {
                       'score': 2.2E-05,
                       'token': 35_676,
                       'token_str': ' Maul',
                       'sequence': '<s>My name is Maul<mask></s>',
                   },
                   {'score': 2.2E-05, 'token': 16_416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
               ],
               [
                   {
                       'score': 2.2E-05,
                       'token': 35_676,
                       'token_str': ' Maul',
                       'sequence': '<s>My name is<mask> Maul</s>',
                   },
                   {'score': 2.2E-05, 'token': 16_416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
               ],
           ]				,				)



 @require_torch_gpu
 def       lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_							=			pipeline('fill-mask'				,				model='hf-internal-testing/tiny-random-distilbert'				,				device=0				,				framework='pt'						)

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

       SCREAMING_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(_lowerCAmelCase				,				_lowerCAmelCase						)



 @slow
 @require_torch
 def       lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_							=			pipeline(task='fill-mask'				,				model='distilroberta-base'				,				top_k=2				,				framework='pt'						)
       self.run_large_test(_lowerCAmelCase						)



 @slow
 @require_tf
 def       lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_							=			pipeline(task='fill-mask'				,				model='distilroberta-base'				,				top_k=2				,				framework='tf'						)
       self.run_large_test(_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		List[str]				,				_lowerCAmelCase  :		Optional[int]						):
       SCREAMING_SNAKE_CASE_							=			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': 1_573, 'token_str': ' Chris'},
           ]				,				)
       SCREAMING_SNAKE_CASE_							=			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': 2_201,
                   'token_str': ' Paris',
               },
               {
                   'sequence': 'The largest city in France is Lyon',
                   'score': 0.214,
                   'token': 12_790,
                   'token_str': ' Lyon',
               },
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			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': 3_499, 'token_str': ' Patrick'},
               {'sequence': 'My name is Clara', 'score': 0.000, 'token': 13_606, 'token_str': ' Clara'},
               {'sequence': 'My name is Te', 'score': 0.000, 'token': 2_941, 'token_str': ' Te'},
           ]				,				)



 @require_torch
 def       lowerCAmelCase_  (							self  :		Optional[int]						):
       SCREAMING_SNAKE_CASE_							=			pipeline(task='fill-mask'				,				model='sshleifer/tiny-distilroberta-base'				,				framework='pt'						)
       SCREAMING_SNAKE_CASE_							=			None
       SCREAMING_SNAKE_CASE_							=			None
       self.run_pipeline_test(_lowerCAmelCase				,				[]						)



 @require_tf
 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_							=			pipeline(task='fill-mask'				,				model='sshleifer/tiny-distilroberta-base'				,				framework='tf'						)
       SCREAMING_SNAKE_CASE_							=			None
       SCREAMING_SNAKE_CASE_							=			None
       self.run_pipeline_test(_lowerCAmelCase				,				[]						)



 def       lowerCAmelCase_  (							self  :		Tuple				,				_lowerCAmelCase  :		Dict				,				_lowerCAmelCase  :		Optional[int]				,				_lowerCAmelCase  :		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)'						)

       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			[
           F"This is another {tokenizer.mask_token} test",
       ]
       return fill_masker, examples



 def       lowerCAmelCase_  (							self  :		List[Any]				,				_lowerCAmelCase  :		Dict				,				_lowerCAmelCase  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_							=			fill_masker.tokenizer
       SCREAMING_SNAKE_CASE_							=			fill_masker.model

       SCREAMING_SNAKE_CASE_							=			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						)},
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			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						)},
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		Tuple				,				_lowerCAmelCase  :		Tuple				,				_lowerCAmelCase  :		List[Any]						):
       SCREAMING_SNAKE_CASE_							=			tokenizer.get_vocab()
       SCREAMING_SNAKE_CASE_							=			sorted(vocab.keys()						)[:2]
       # Pipeline argument
       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase				,				targets=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			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						)},
           ]				,				)
       SCREAMING_SNAKE_CASE_							=			{vocab[el] for el in targets}
       self.assertEqual({el['token'] for el in outputs}				,				_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			[tokenizer.decode([x]						) for x in target_ids]
       self.assertEqual({el['token_str'] for el in outputs}				,				set(_lowerCAmelCase						)						)

       # Call argument
       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			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						)},
           ]				,				)
       SCREAMING_SNAKE_CASE_							=			{vocab[el] for el in targets}
       self.assertEqual({el['token'] for el in outputs}				,				_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			[tokenizer.decode([x]						) for x in target_ids]
       self.assertEqual({el['token_str'] for el in outputs}				,				set(_lowerCAmelCase						)						)

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

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



 def       lowerCAmelCase_  (							self  :		Dict				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		int						):
       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase				,				top_k=2						)
       SCREAMING_SNAKE_CASE_							=			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						)},
           ]				,				)

       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		int				,				_lowerCAmelCase  :		int				,				_lowerCAmelCase  :		int						):
       SCREAMING_SNAKE_CASE_							=			tokenizer.get_vocab()
       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase						)

       # top_k=2, ntargets=3
       SCREAMING_SNAKE_CASE_							=			sorted(vocab.keys()						)[:3]
       SCREAMING_SNAKE_CASE_							=			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
       SCREAMING_SNAKE_CASE_							=			[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						):
             SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		Dict				,				_lowerCAmelCase  :		List[Any]				,				_lowerCAmelCase  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			tokenizer.get_vocab()
       # String duplicates + id duplicates
       SCREAMING_SNAKE_CASE_							=			sorted(vocab.keys()						)[:3]
       SCREAMING_SNAKE_CASE_							=			[targets[0], targets[1], targets[0], targets[2], targets[1]]
       SCREAMING_SNAKE_CASE_							=			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       lowerCAmelCase_  (							self  :		Optional[Any]				,				_lowerCAmelCase  :		List[str]				,				_lowerCAmelCase  :		Any						):
       SCREAMING_SNAKE_CASE_							=			FillMaskPipeline(model=_lowerCAmelCase				,				tokenizer=_lowerCAmelCase						)

       SCREAMING_SNAKE_CASE_							=			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						)},
               ],
           ]				,				)





import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402





class        lowerCamelCase_							(      unittest.TestCase					):


 '''simple docstring'''







 def       lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_							=			0



 def       lowerCAmelCase_  (							self  :		int						):
       SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained('openai/clip-vit-base-patch32'						)
       self.assertIsInstance(_lowerCAmelCase				,				_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		Optional[int]						):
       with tempfile.TemporaryDirectory() as tmpdirname:
             SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'preprocessor_config.json'
             SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'config.json'
             json.dump(
                 {'image_processor_type': 'CLIPImageProcessor', 'processor_class': 'CLIPProcessor'}				,				open(_lowerCAmelCase				,				'w'						)				,				)
             json.dump({'model_type': 'clip'}				,				open(_lowerCAmelCase				,				'w'						)						)

             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase						)
             self.assertIsInstance(_lowerCAmelCase				,				_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		str						):
       # Ensure we can load the image processor from the feature extractor config
       with tempfile.TemporaryDirectory() as tmpdirname:
             SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'preprocessor_config.json'
             SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'config.json'
             json.dump(
                 {'feature_extractor_type': 'CLIPFeatureExtractor', 'processor_class': 'CLIPProcessor'}				,				open(_lowerCAmelCase				,				'w'						)				,				)
             json.dump({'model_type': 'clip'}				,				open(_lowerCAmelCase				,				'w'						)						)

             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase						)
             self.assertIsInstance(_lowerCAmelCase				,				_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):
       with tempfile.TemporaryDirectory() as tmpdirname:
             SCREAMING_SNAKE_CASE_							=			CLIPConfig()

             # Create a dummy config file with image_proceesor_type
             SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'preprocessor_config.json'
             SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'config.json'
             json.dump(
                 {'image_processor_type': 'CLIPImageProcessor', 'processor_class': 'CLIPProcessor'}				,				open(_lowerCAmelCase				,				'w'						)				,				)
             json.dump({'model_type': 'clip'}				,				open(_lowerCAmelCase				,				'w'						)						)

             # remove image_processor_type to make sure config.json alone is enough to load image processor locally
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase						).to_dict()

             config_dict.pop('image_processor_type'						)
             SCREAMING_SNAKE_CASE_							=			CLIPImageProcessor(**_lowerCAmelCase						)

             # save in new folder
             model_config.save_pretrained(_lowerCAmelCase						)
             config.save_pretrained(_lowerCAmelCase						)

             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase						)

             # make sure private variable is not incorrectly saved
             SCREAMING_SNAKE_CASE_							=			json.loads(config.to_json_string()						)
             self.assertTrue('_processor_class' not in dict_as_saved						)

       self.assertIsInstance(_lowerCAmelCase				,				_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		str						):
       with tempfile.TemporaryDirectory() as tmpdirname:
             SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'preprocessor_config.json'
             json.dump(
                 {'image_processor_type': 'CLIPImageProcessor', 'processor_class': 'CLIPProcessor'}				,				open(_lowerCAmelCase				,				'w'						)				,				)

             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase						)
             self.assertIsInstance(_lowerCAmelCase				,				_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		List[Any]						):
       with self.assertRaisesRegex(
           _lowerCAmelCase				,				'clip-base is not a local folder and is not a valid model identifier'						):
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained('clip-base'						)



 def       lowerCAmelCase_  (							self  :		List[Any]						):
       with self.assertRaisesRegex(
           _lowerCAmelCase				,				R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'						):
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase				,				revision='aaaaaa'						)



 def       lowerCAmelCase_  (							self  :		str						):
       with self.assertRaisesRegex(
           _lowerCAmelCase				,				'hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'				,				):
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained('hf-internal-testing/config-no-model'						)



 def       lowerCAmelCase_  (							self  :		Tuple						):
       # If remote code is not set, we will time out when asking whether to load the model.
       with self.assertRaises(_lowerCAmelCase						):
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained('hf-internal-testing/test_dynamic_image_processor'						)
       # If remote code is disabled, we can't load this config.
       with self.assertRaises(_lowerCAmelCase						):
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/test_dynamic_image_processor'				,				trust_remote_code=_lowerCAmelCase						)

       SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(
           'hf-internal-testing/test_dynamic_image_processor'				,				trust_remote_code=_lowerCAmelCase						)
       self.assertEqual(image_processor.__class__.__name__				,				'NewImageProcessor'						)

       # Test image processor can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
             image_processor.save_pretrained(_lowerCAmelCase						)
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase				,				trust_remote_code=_lowerCAmelCase						)
       self.assertEqual(reloaded_image_processor.__class__.__name__				,				'NewImageProcessor'						)



 def       lowerCAmelCase_  (							self  :		Optional[Any]						):
       try:
             AutoConfig.register('custom'				,				_lowerCAmelCase						)
             AutoImageProcessor.register(_lowerCAmelCase				,				_lowerCAmelCase						)
             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(_lowerCAmelCase						):
                   AutoImageProcessor.register(_lowerCAmelCase				,				_lowerCAmelCase						)

             with tempfile.TemporaryDirectory() as tmpdirname:
                   SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'preprocessor_config.json'
                   SCREAMING_SNAKE_CASE_							=			Path(_lowerCAmelCase						) / 'config.json'
                   json.dump(
                       {'feature_extractor_type': 'CLIPFeatureExtractor', 'processor_class': 'CLIPProcessor'}				,				open(_lowerCAmelCase				,				'w'						)				,				)
                   json.dump({'model_type': 'clip'}				,				open(_lowerCAmelCase				,				'w'						)						)

                   SCREAMING_SNAKE_CASE_							=			CustomImageProcessor.from_pretrained(_lowerCAmelCase						)

             # Now that the config is registered, it can be used as any other config with the auto-API
             with tempfile.TemporaryDirectory() as tmp_dir:
                   image_processor.save_pretrained(_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(_lowerCAmelCase						)
                   self.assertIsInstance(_lowerCAmelCase				,				_lowerCAmelCase						)

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
                   del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]




 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):





       class        lowerCamelCase_							(      _SCREAMING_SNAKE_CASE					):


        '''simple docstring'''







        lowercase_				    =    True

       try:
             AutoConfig.register('custom'				,				_lowerCAmelCase						)
             AutoImageProcessor.register(_lowerCAmelCase				,				_lowerCAmelCase						)
             # If remote code is not set, the default is to use local
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained('hf-internal-testing/test_dynamic_image_processor'						)
             self.assertEqual(image_processor.__class__.__name__				,				'NewImageProcessor'						)
             self.assertTrue(image_processor.is_local						)

             # If remote code is disabled, we load the local one.
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/test_dynamic_image_processor'				,				trust_remote_code=_lowerCAmelCase						)
             self.assertEqual(image_processor.__class__.__name__				,				'NewImageProcessor'						)
             self.assertTrue(image_processor.is_local						)

             # If remote is enabled, we load from the Hub
             SCREAMING_SNAKE_CASE_							=			AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/test_dynamic_image_processor'				,				trust_remote_code=_lowerCAmelCase						)
             self.assertEqual(image_processor.__class__.__name__				,				'NewImageProcessor'						)
             self.assertTrue(not hasattr(_lowerCAmelCase				,				'is_local'						)						)

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
                   del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]