




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		:      Dict		 =     MODEL_FOR_MASKED_LM_MAPPING
     a		:      Tuple		 =     TF_MODEL_FOR_MASKED_LM_MAPPING







     def       lowerCAmelCase_    (     self			)  ->   Tuple:



          '''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       lowerCAmelCase_    (     self			)  ->   List[Any]:



          '''simple docstring'''



          a     =				pipeline(task="fill-mask"  ,		model="sshleifer/tiny-distilroberta-base"  ,		top_k=2  ,		framework="tf"			)
          a     =				unmasker("My name is <mask>"			)
          self.assertEqual(
              nested_simplify(A  ,		decimals=6			)  ,		[
                  {"sequence": "My name is grouped", "score": 2.1e-05, "token": 38015, "token_str": " grouped"},
                  {"sequence": "My name is accuser", "score": 2.1e-05, "token": 25506, "token_str": " accuser"},
              ]  ,		)

          a     =				unmasker("The largest city in France is <mask>"			)
          self.assertEqual(
              nested_simplify(A  ,		decimals=6			)  ,		[
                  {
                      "sequence": "The largest city in France is grouped",
                      "score": 2.1e-05,
                      "token": 38015,
                      "token_str": " grouped",
                  },
                  {
                      "sequence": "The largest city in France is accuser",
                      "score": 2.1e-05,
                      "token": 25506,
                      "token_str": " accuser",
                  },
              ]  ,		)

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







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



          '''simple docstring'''



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

          a     =				unmasker("My name is <mask>"			)
          self.assertEqual(
              nested_simplify(A  ,		decimals=6			)  ,		[
                  {"sequence": "My name is Maul", "score": 2.2e-05, "token": 35676, "token_str": " Maul"},
                  {"sequence": "My name isELS", "score": 2.2e-05, "token": 16416, "token_str": "ELS"},
              ]  ,		)

          a     =				unmasker("The largest city in France is <mask>"			)
          self.assertEqual(
              nested_simplify(A  ,		decimals=6			)  ,		[
                  {
                      "sequence": "The largest city in France is Maul",
                      "score": 2.2e-05,
                      "token": 35676,
                      "token_str": " Maul",
                  },
                  {"sequence": "The largest city in France isELS", "score": 2.2e-05, "token": 16416, "token_str": "ELS"},
              ]  ,		)

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

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

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







     @require_torch_gpu
     def       lowerCAmelCase_    (     self			)  ->   int:



          '''simple docstring'''



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

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

          a     =				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(A  ,		A			)







     @slow
     @require_torch
     def       lowerCAmelCase_    (     self			)  ->   List[Any]:



          '''simple docstring'''



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







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



          '''simple docstring'''



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







     def       lowerCAmelCase_    (     self  ,		A			)  ->   Dict:



          '''simple docstring'''



          a     =				unmasker("My name is <mask>"			)
          self.assertEqual(
              nested_simplify(A			)  ,		[
                  {"sequence": "My name is John", "score": 0.0_0_8, "token": 610, "token_str": " John"},
                  {"sequence": "My name is Chris", "score": 0.0_0_7, "token": 1573, "token_str": " Chris"},
              ]  ,		)
          a     =				unmasker("The largest city in France is <mask>"			)
          self.assertEqual(
              nested_simplify(A			)  ,		[
                  {
                      "sequence": "The largest city in France is Paris",
                      "score": 0.2_5_1,
                      "token": 2201,
                      "token_str": " Paris",
                  },
                  {
                      "sequence": "The largest city in France is Lyon",
                      "score": 0.2_1_4,
                      "token": 12790,
                      "token_str": " Lyon",
                  },
              ]  ,		)

          a     =				unmasker("My name is <mask>"  ,		targets=[" Patrick", " Clara", " Teven"]  ,		top_k=3			)
          self.assertEqual(
              nested_simplify(A			)  ,		[
                  {"sequence": "My name is Patrick", "score": 0.0_0_5, "token": 3499, "token_str": " Patrick"},
                  {"sequence": "My name is Clara", "score": 0.0_0_0, "token": 13606, "token_str": " Clara"},
                  {"sequence": "My name is Te", "score": 0.0_0_0, "token": 2941, "token_str": " Te"},
              ]  ,		)







     @require_torch
     def       lowerCAmelCase_    (     self			)  ->   Optional[int]:



          '''simple docstring'''



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







     @require_tf
     def       lowerCAmelCase_    (     self			)  ->   Union[str, Any]:



          '''simple docstring'''



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







     def       lowerCAmelCase_    (     self  ,		A  ,		A  ,		A			)  ->   Optional[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)"			)

          a     =				FillMaskPipeline(model=A  ,		tokenizer=A			)
          a     =				[
              F'''This is another {tokenizer.mask_token} test''',
          ]
          return fill_masker, examples







     def       lowerCAmelCase_    (     self  ,		A  ,		A			)  ->   str:



          '''simple docstring'''



          a     =				fill_masker.tokenizer
          a     =				fill_masker.model

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

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

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

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

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







     def       lowerCAmelCase_    (     self  ,		A  ,		A			)  ->   Any:



          '''simple docstring'''



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

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

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

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







     def       lowerCAmelCase_    (     self  ,		A  ,		A			)  ->   Dict:



          '''simple docstring'''



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

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







     def       lowerCAmelCase_    (     self  ,		A  ,		A			)  ->   Tuple:



          '''simple docstring'''



          a     =				tokenizer.get_vocab()
          a     =				FillMaskPipeline(model=A  ,		tokenizer=A			)

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

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







     def       lowerCAmelCase_    (     self  ,		A  ,		A			)  ->   Dict:



          '''simple docstring'''



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

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







     def       lowerCAmelCase_    (     self  ,		A  ,		A			)  ->   str:



          '''simple docstring'''



          a     =				FillMaskPipeline(model=A  ,		tokenizer=A			)

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







# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

lowercase__				:      str	   = TypeVar("T")




class       a__	( Generic[T]				):







     def __init__(     self  ,		A = True			)  ->   None:



          '''simple docstring'''



          a     =				{}  # dictionary of lists
          a     =				directed







     def       lowerCAmelCase_    (     self  ,		A  ,		A			)  ->   GraphAdjacencyList[T]:



          '''simple docstring'''



          if not self.directed:  # For undirected graphs
               # if both source vertex and destination vertex are both present in the
               # adjacency list, add destination vertex to source vertex list of adjacent
               # vertices and add source vertex to destination vertex list of adjacent
               # vertices.
               if source_vertex in self.adj_list and destination_vertex in self.adj_list:
                    self.adj_list[source_vertex].append(A			)
                    self.adj_list[destination_vertex].append(A			)
               # if only source vertex is present in adjacency list, add destination vertex
               # to source vertex list of adjacent vertices, then create a new vertex with
               # destination vertex as key and assign a list containing the source vertex
               # as it's first adjacent vertex.
               elif source_vertex in self.adj_list:
                    self.adj_list[source_vertex].append(A			)
                    a     =				[source_vertex]
               # if only destination vertex is present in adjacency list, add source vertex
               # to destination vertex list of adjacent vertices, then create a new vertex
               # with source vertex as key and assign a list containing the source vertex
               # as it's first adjacent vertex.
               elif destination_vertex in self.adj_list:
                    self.adj_list[destination_vertex].append(A			)
                    a     =				[destination_vertex]
               # if both source vertex and destination vertex are not present in adjacency
               # list, create a new vertex with source vertex as key and assign a list
               # containing the destination vertex as it's first adjacent vertex also
               # create a new vertex with destination vertex as key and assign a list
               # containing the source vertex as it's first adjacent vertex.
               else:
                    a     =				[destination_vertex]
                    a     =				[source_vertex]
          else:  # For directed graphs
               # if both source vertex and destination vertex are present in adjacency
               # list, add destination vertex to source vertex list of adjacent vertices.
               if source_vertex in self.adj_list and destination_vertex in self.adj_list:
                    self.adj_list[source_vertex].append(A			)
               # if only source vertex is present in adjacency list, add destination
               # vertex to source vertex list of adjacent vertices and create a new vertex
               # with destination vertex as key, which has no adjacent vertex
               elif source_vertex in self.adj_list:
                    self.adj_list[source_vertex].append(A			)
                    a     =				[]
               # if only destination vertex is present in adjacency list, create a new
               # vertex with source vertex as key and assign a list containing destination
               # vertex as first adjacent vertex
               elif destination_vertex in self.adj_list:
                    a     =				[destination_vertex]
               # if both source vertex and destination vertex are not present in adjacency
               # list, create a new vertex with source vertex as key and a list containing
               # destination vertex as it's first adjacent vertex. Then create a new vertex
               # with destination vertex as key, which has no adjacent vertex
               else:
                    a     =				[destination_vertex]
                    a     =				[]

          return self







     def __repr__(     self			)  ->   str:



          '''simple docstring'''



          return pformat(self.adj_list			)

