


"""simple docstring"""







from math import sqrt
def 					a__			(				SCREAMING_SNAKE_CASE    :    int				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (
      number >= 0
  ), "'number' must been an int and positive"

  lowerCAmelCase     :     Any								=							True

  # 0 and 1 are none primes.
  if number <= 1:
    lowerCAmelCase     :     Any								=							False

  for divisor in range(2				,      int(round(sqrt(SCREAMING_SNAKE_CASE				)				)				) + 1				):
    # if 'number' divisible by 'divisor' then sets 'status'
    # of false and break up the loop.
    if number % divisor == 0:
      lowerCAmelCase     :     Optional[Any]								=							False
      break

    # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'status' must been from type bool"

  return status
def 					a__			(				SCREAMING_SNAKE_CASE    :    str				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (n > 2), "'N' must been an int and > 2"

  # beginList: contains all natural numbers from 2 up to N
  lowerCAmelCase     :     Tuple								=							list(range(2				,      n + 1				)				)

  lowerCAmelCase     :     List[Any]								=							[]  # this list will be returns.

  # actual sieve of erathostenes
  for i in range(len(SCREAMING_SNAKE_CASE				)				):
    for j in range(i + 1				,      len(SCREAMING_SNAKE_CASE				)				):
      if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
        lowerCAmelCase     :     Tuple								=							0

    # filters actual prime numbers.
  lowerCAmelCase     :     str								=							[x for x in begin_list if x != 0]

  # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'ans' must been from type list"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    Any				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (n > 2), "'N' must been an int and > 2"

  lowerCAmelCase     :     str								=							[]

  # iterates over all numbers between 2 up to N+1
  # if a number is prime then appends to list 'ans'
  for number in range(2				,      n + 1				):
    if is_prime(SCREAMING_SNAKE_CASE				):
      ans.append(SCREAMING_SNAKE_CASE				)

    # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'ans' must been from type list"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    Optional[Any]				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and number >= 0, "'number' must been an int and >= 0"

  lowerCAmelCase     :     Optional[Any]								=							[]  # this list will be returns of the function.

  # potential prime number factors.

  lowerCAmelCase     :     Optional[Any]								=							2

  lowerCAmelCase     :     Optional[Any]								=							number

  if number == 0 or number == 1:
    ans.append(SCREAMING_SNAKE_CASE				)

  # if 'number' not prime then builds the prime factorization of 'number'
  elif not is_prime(SCREAMING_SNAKE_CASE				):
    while quotient != 1:
      if is_prime(SCREAMING_SNAKE_CASE				) and (quotient % factor == 0):
        ans.append(SCREAMING_SNAKE_CASE				)
        quotient /= factor
      else:
        factor += 1

  else:
    ans.append(SCREAMING_SNAKE_CASE				)

  # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'ans' must been from type list"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    str				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (
      number >= 0
  ), "'number' bust been an int and >= 0"

  lowerCAmelCase     :     List[Any]								=							0

  # prime factorization of 'number'
  lowerCAmelCase     :     Union[str, Any]								=							prime_factorization(SCREAMING_SNAKE_CASE				)

  lowerCAmelCase     :     Any								=							max(SCREAMING_SNAKE_CASE				)

  # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'ans' must been from type int"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    List[Any]				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (
      number >= 0
  ), "'number' bust been an int and >= 0"

  lowerCAmelCase     :     Any								=							0

  # prime factorization of 'number'
  lowerCAmelCase     :     str								=							prime_factorization(SCREAMING_SNAKE_CASE				)

  lowerCAmelCase     :     List[Any]								=							min(SCREAMING_SNAKE_CASE				)

  # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'ans' must been from type int"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    Dict				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'number' must been an int"
  assert isinstance(number % 2 == 0				,      SCREAMING_SNAKE_CASE				), "compare bust been from type bool"

  return number % 2 == 0
def 					a__			(				SCREAMING_SNAKE_CASE    :    int				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				), "'number' must been an int"
  assert isinstance(number % 2 != 0				,      SCREAMING_SNAKE_CASE				), "compare bust been from type bool"

  return number % 2 != 0
def 					a__			(				SCREAMING_SNAKE_CASE    :    Optional[int]				):


  '''simple docstring'''







  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (number > 2) and is_even(SCREAMING_SNAKE_CASE				)
  ), "'number' must been an int, even and > 2"

  lowerCAmelCase     :     str								=							[]  # this list will returned

  # creates a list of prime numbers between 2 up to 'number'
  lowerCAmelCase     :     Any								=							get_prime_numbers(SCREAMING_SNAKE_CASE				)
  lowerCAmelCase     :     Optional[int]								=							len(SCREAMING_SNAKE_CASE				)

  # run variable for while-loops.
  lowerCAmelCase     :     Dict								=							0
  lowerCAmelCase     :     Optional[int]								=							None

  # exit variable. for break up the loops
  lowerCAmelCase     :     Optional[int]								=							True

  while i < len_pn and loop:
    lowerCAmelCase     :     int								=							i + 1

    while j < len_pn and loop:
      if prime_numbers[i] + prime_numbers[j] == number:
        lowerCAmelCase     :     Dict								=							False
        ans.append(prime_numbers[i]				)
        ans.append(prime_numbers[j]				)

      j += 1

    i += 1

  # precondition
  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and (len(SCREAMING_SNAKE_CASE				) == 2)
      and (ans[0] + ans[1] == number)
      and is_prime(ans[0]				)
      and is_prime(ans[1]				)
  ), "'ans' must contains two primes. And sum of elements must been eq 'number'"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    Tuple				,      SCREAMING_SNAKE_CASE    :    Any				):


  '''simple docstring'''







  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and (numbera >= 0)
      and (numbera >= 0)
  ), "'number1' and 'number2' must been positive integer."

  lowerCAmelCase     :     int								=							0

  while numbera != 0:
    lowerCAmelCase     :     Dict								=							numbera % numbera
    lowerCAmelCase     :     int								=							numbera
    lowerCAmelCase     :     Optional[Any]								=							rest

  # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (
      numbera >= 0
  ), "'number' must been from type int and positive"

  return numbera
def 					a__			(				SCREAMING_SNAKE_CASE    :    Optional[int]				,      SCREAMING_SNAKE_CASE    :    List[str]				):


  '''simple docstring'''







  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and (numbera >= 1)
      and (numbera >= 1)
  ), "'number1' and 'number2' must been positive integer."

  lowerCAmelCase     :     List[str]								=							1  # actual answer that will be return.

  # for kgV (x,1)
  if numbera > 1 and numbera > 1:
    # builds the prime factorization of 'number1' and 'number2'
    lowerCAmelCase     :     Dict								=							prime_factorization(SCREAMING_SNAKE_CASE				)
    lowerCAmelCase     :     Optional[int]								=							prime_factorization(SCREAMING_SNAKE_CASE				)

  elif numbera == 1 or numbera == 1:
    lowerCAmelCase     :     Any								=							[]
    lowerCAmelCase     :     Tuple								=							[]
    lowerCAmelCase     :     List[str]								=							max(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)

  lowerCAmelCase     :     Optional[int]								=							0
  lowerCAmelCase     :     Optional[Any]								=							0

  lowerCAmelCase     :     Union[str, Any]								=							[]  # captured numbers int both 'primeFac1' and 'primeFac2'

  # iterates through primeFac1
  for n in prime_fac_a:
    if n not in done:
      if n in prime_fac_a:
        lowerCAmelCase     :     Any								=							prime_fac_a.count(SCREAMING_SNAKE_CASE				)
        lowerCAmelCase     :     int								=							prime_fac_a.count(SCREAMING_SNAKE_CASE				)

        for _ in range(max(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)				):
          ans *= n

      else:
        lowerCAmelCase     :     List[str]								=							prime_fac_a.count(SCREAMING_SNAKE_CASE				)

        for _ in range(SCREAMING_SNAKE_CASE				):
          ans *= n

      done.append(SCREAMING_SNAKE_CASE				)

    # iterates through primeFac2
  for n in prime_fac_a:
    if n not in done:
      lowerCAmelCase     :     Any								=							prime_fac_a.count(SCREAMING_SNAKE_CASE				)

      for _ in range(SCREAMING_SNAKE_CASE				):
        ans *= n

      done.append(SCREAMING_SNAKE_CASE				)

    # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (
      ans >= 0
  ), "'ans' must been from type int and positive"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    Any				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (n >= 0), "'number' must been a positive int"

  lowerCAmelCase     :     int								=							0
  lowerCAmelCase     :     Tuple								=							2  # this variable holds the answer

  while index < n:
    index += 1

    ans += 1  # counts to the next number

    # if ans not prime then
    # runs to the next prime number.
    while not is_prime(SCREAMING_SNAKE_CASE				):
      ans += 1

    # precondition
  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and is_prime(
      SCREAMING_SNAKE_CASE				), "'ans' must been a prime number and from type int"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    List[Any]				,      SCREAMING_SNAKE_CASE    :    Optional[Any]				):


  '''simple docstring'''







  assert (
      is_prime(SCREAMING_SNAKE_CASE				) and is_prime(SCREAMING_SNAKE_CASE				) and (p_number_a < p_number_a)
  ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

  lowerCAmelCase     :     List[Any]								=							p_number_a + 1  # jump to the next number

  lowerCAmelCase     :     Tuple								=							[]  # this list will be returns.

  # if number is not prime then
  # fetch the next prime number.
  while not is_prime(SCREAMING_SNAKE_CASE				):
    number += 1

  while number < p_number_a:
    ans.append(SCREAMING_SNAKE_CASE				)

    number += 1

    # fetch the next prime number.
    while not is_prime(SCREAMING_SNAKE_CASE				):
      number += 1

    # precondition
  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and ans[0] != p_number_a
      and ans[len(SCREAMING_SNAKE_CASE				) - 1] != p_number_a
  ), "'ans' must been a list without the arguments"

  # 'ans' contains not 'pNumber1' and 'pNumber2' !
  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    Optional[int]				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (n >= 1), "'n' must been int and >= 1"

  lowerCAmelCase     :     Any								=							[]  # will be returned.

  for divisor in range(1				,      n + 1				):
    if n % divisor == 0:
      ans.append(SCREAMING_SNAKE_CASE				)

    # precondition
  assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE				) - 1] == n, "Error in function getDivisiors(...)"

  return ans
def 					a__			(				SCREAMING_SNAKE_CASE    :    List[Any]				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (
      number > 1
  ), "'number' must been an int and >= 1"

  lowerCAmelCase     :     Any								=							get_divisors(SCREAMING_SNAKE_CASE				)

  # precondition
  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and (divisors[0] == 1)
      and (divisors[len(SCREAMING_SNAKE_CASE				) - 1] == number)
  ), "Error in help-function getDivisiors(...)"

  # summed all divisors up to 'number' (exclusive), hence [:-1]
  return sum(divisors[:-1]				) == number
def 					a__			(				SCREAMING_SNAKE_CASE    :    List[str]				,      SCREAMING_SNAKE_CASE    :    Tuple				):


  '''simple docstring'''







  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and (denominator != 0)
  ), "The arguments must been from type int and 'denominator' != 0"

  # build the greatest common divisor of numerator and denominator.
  lowerCAmelCase     :     Any								=							gcd(abs(SCREAMING_SNAKE_CASE				)				,      abs(SCREAMING_SNAKE_CASE				)				)

  # precondition
  assert (
      isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
      and (numerator % gcd_of_fraction == 0)
      and (denominator % gcd_of_fraction == 0)
  ), "Error in function gcd(...,...)"

  return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)
def 					a__			(				SCREAMING_SNAKE_CASE    :    Any				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (n >= 0), "'n' must been a int and >= 0"

  lowerCAmelCase     :     Any								=							1  # this will be return.

  for factor in range(1				,      n + 1				):
    ans *= factor

  return ans





def 					a__			(				SCREAMING_SNAKE_CASE    :    str				):


  '''simple docstring'''







  assert isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				) and (n >= 0), "'n' must been an int and >= 0"

  lowerCAmelCase     :     Union[str, Any]								=							0
  lowerCAmelCase     :     Tuple								=							1
  lowerCAmelCase     :     Any								=							1  # this will be return

  for _ in range(n - 1				):
    lowerCAmelCase     :     List[str]								=							ans
    ans += fiba
    lowerCAmelCase     :     Optional[Any]								=							tmp

  return ans







from typing import Dict

import numpy as np

from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline, PipelineException


if is_tf_available():
  import tensorflow as tf

  from ..tf_utils import stable_softmax


if is_torch_available():
  import torch


lowercase  :					List[str]						    =							logging.get_logger(__name__)

@add_end_docstrings(
    lowerCAmelCase					,	R"\n        top_k (`int`, defaults to 5):\n            The number of predictions to return.\n        targets (`str` or `List[str]`, *optional*):\n            When passed, the model will limit the scores to the passed targets instead of looking up in the whole\n            vocab. If the provided targets are not in the model vocab, they will be tokenized and the first resulting\n            token will be used (with a warning, and that might be slower).\n\n    "					,	)
class __snake_case		(      lowerCAmelCase     ):
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           if self.framework == "tf":
                  lowercase							:     str       	=      tf.where(input_ids == self.tokenizer.mask_token_id      ).numpy()
           elif self.framework == "pt":
                  lowercase							:     Optional[int]       	=      torch.nonzero(input_ids == self.tokenizer.mask_token_id		,as_tuple=snake_case      )
           else:
                  raise ValueError("""Unsupported framework"""      )
           return masked_index
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Tuple       	=      self.get_masked_index(snake_case      )
           lowercase							:     Dict       	=      np.prod(masked_index.shape      )
           if numel < 1:
                  raise PipelineException(
                      """fill-mask"""		,self.model.base_model_prefix		,f"No mask_token ({self.tokenizer.mask_token}) found on the input"		,)
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           if isinstance(snake_case		,snake_case      ):
                  for model_input in model_inputs:
                         self._ensure_exactly_one_mask_token(model_input["""input_ids"""][0]      )
           else:
                  for input_ids in model_inputs["input_ids"]:
                         self._ensure_exactly_one_mask_token(snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case=None		,**snake_case      ):



           '''simple docstring'''







           if return_tensors is None:
                  lowercase							:     int       	=      self.framework
           lowercase							:     Optional[Any]       	=      self.tokenizer(snake_case		,return_tensors=snake_case      )
           self.ensure_exactly_one_mask_token(snake_case      )
           return model_inputs
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Optional[int]       	=      self.model(**snake_case      )
           lowercase							:     Tuple       	=      model_inputs["""input_ids"""]
           return model_outputs
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case=5		,snake_case=None      ):



           '''simple docstring'''







           if target_ids is not None and target_ids.shape[0] < top_k:
                  lowercase							:     str       	=      target_ids.shape[0]
           lowercase							:     Optional[Any]       	=      model_outputs["""input_ids"""][0]
           lowercase							:     List[str]       	=      model_outputs["""logits"""]

           if self.framework == "tf":
                  lowercase							:     List[str]       	=      tf.where(input_ids == self.tokenizer.mask_token_id      ).numpy()[:, 0]

                  lowercase							:     Tuple       	=      outputs.numpy()

                  lowercase							:     Tuple       	=      outputs[0, masked_index, :]
                  lowercase							:     Any       	=      stable_softmax(snake_case		,axis=-1      )
                  if target_ids is not None:
                         lowercase							:     Union[str, Any]       	=      tf.gather_nd(tf.squeeze(snake_case		,0      )		,target_ids.reshape(-1		,1      )      )
                         lowercase							:     int       	=      tf.expand_dims(snake_case		,0      )

                  lowercase							:     Tuple       	=      tf.math.top_k(snake_case		,k=snake_case      )
                  lowercase	,			lowercase							:     int       	=      topk.values.numpy(), topk.indices.numpy()
           else:
                  lowercase							:     Optional[Any]       	=      torch.nonzero(input_ids == self.tokenizer.mask_token_id		,as_tuple=snake_case      ).squeeze(-1      )
                  # Fill mask pipeline supports only one ${mask_token} per sample

                  lowercase							:     Union[str, Any]       	=      outputs[0, masked_index, :]
                  lowercase							:     Tuple       	=      logits.softmax(dim=-1      )
                  if target_ids is not None:
                         lowercase							:     List[str]       	=      probs[..., target_ids]

                  lowercase	,			lowercase							:     Union[str, Any]       	=      probs.topk(snake_case      )

           lowercase							:     Any       	=      []
           lowercase							:     List[Any]       	=      values.shape[0] == 1
           for i, (_values, _predictions) in enumerate(zip(values.tolist()		,predictions.tolist()      )      ):
                  lowercase							:     Dict       	=      []
                  for v, p in zip(_values		,_predictions      ):
                         # Copy is important since we're going to modify this array in place
                         lowercase							:     Dict       	=      input_ids.numpy().copy()
                         if target_ids is not None:
                                lowercase							:     Union[str, Any]       	=      target_ids[p].tolist()

                         lowercase							:     Tuple       	=      p
                         # Filter padding out:
                         lowercase							:     List[str]       	=      tokens[np.where(tokens != self.tokenizer.pad_token_id      )]
                         # Originally we skip special tokens to give readable output.
                         # For multi masks though, the other [MASK] would be removed otherwise
                         # making the output look odd, so we add them back
                         lowercase							:     Tuple       	=      self.tokenizer.decode(snake_case		,skip_special_tokens=snake_case      )
                         lowercase							:     Optional[Any]       	=      {"""score""": v, """token""": p, """token_str""": self.tokenizer.decode([p]      ), """sequence""": sequence}
                         row.append(snake_case      )
                  result.append(snake_case      )
           if single_mask:
                  return result[0]
           return result
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case=None      ):



           '''simple docstring'''







           if isinstance(snake_case		,snake_case      ):
                  lowercase							:     List[Any]       	=      [targets]
           try:
                  lowercase							:     List[str]       	=      self.tokenizer.get_vocab()
           except Exception:
                  lowercase							:     Any       	=      {}
           lowercase							:     Dict       	=      []
           for target in targets:
                  lowercase							:     Dict       	=      vocab.get(snake_case		,snake_case      )
                  if id_ is None:
                         lowercase							:     Optional[int]       	=      self.tokenizer(
                             snake_case		,add_special_tokens=snake_case		,return_attention_mask=snake_case		,return_token_type_ids=snake_case		,max_length=1		,truncation=snake_case		,)["""input_ids"""]
                         if len(snake_case      ) == 0:
                                logger.warning(
                                    f"The specified target token `{target}` does not exist in the model vocabulary. "
                                    """We cannot replace it with anything meaningful, ignoring it"""      )
                                continue
                         lowercase							:     Union[str, Any]       	=      input_ids[0]
                         # XXX: If users encounter this pass
                         # it becomes pretty slow, so let's make sure
                         # The warning enables them to fix the input to
                         # get faster performance.
                         logger.warning(
                             f"The specified target token `{target}` does not exist in the model vocabulary. "
                             f"Replacing with `{self.tokenizer.convert_ids_to_tokens(id_      )}`."      )
                  target_ids.append(id_      )
           lowercase							:     Optional[Any]       	=      list(set(snake_case      )      )
           if len(snake_case      ) == 0:
                  raise ValueError("""At least one target must be provided when passed."""      )
           lowercase							:     Optional[Any]       	=      np.array(snake_case      )
           return target_ids
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case=None		,snake_case=None      ):



           '''simple docstring'''







           lowercase							:     Dict       	=      {}

           if targets is not None:
                  lowercase							:     str       	=      self.get_target_ids(snake_case		,snake_case      )
                  lowercase							:     List[Any]       	=      target_ids

           if top_k is not None:
                  lowercase							:     List[str]       	=      top_k

           if self.tokenizer.mask_token_id is None:
                  raise PipelineException(
                      """fill-mask"""		,self.model.base_model_prefix		,"""The tokenizer does not define a `mask_token`."""      )
           return {}, {}, postprocess_params
    def __call__(  self		,snake_case		,*snake_case		,**snake_case      ):



           '''simple docstring'''







           lowercase							:     Tuple       	=      super().__call__(snake_case		,**snake_case      )
           if isinstance(snake_case		,snake_case      ) and len(snake_case      ) == 1:
                  return outputs[0]
           return outputs
