






'''simple docstring'''
from typing import List, Union

import numpy as np

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, logging
from .base import PIPELINE_INIT_ARGS, ArgumentHandler, ChunkPipeline


a_					= logging.get_logger(__name__)






class      __SCREAMING_SNAKE_CASE      (			lowerCamelCase				):




 def      __magic_name__	(      self	:							List[Any]					,      __lowercase	:							int      )	->						str:
       if isinstance(__lowercase					,      __lowercase      ):
             SCREAMING_SNAKE_CASE__     :				Tuple									=[label.strip() for label in labels.split(''','''      ) if label.strip()]
       return labels




 def __call__(      self	:							Dict					,      __lowercase	:							Optional[int]					,      __lowercase	:							str					,      __lowercase	:							Optional[Any]      )	->						Any:
       if len(__lowercase      ) == 0 or len(__lowercase      ) == 0:
             raise ValueError('''You must include at least one label and at least one sequence.'''      )
       if hypothesis_template.format(labels[0]      ) == hypothesis_template:
             raise ValueError(
                 (
                     '''The provided hypothesis_template "{}" was not able to be formatted with the target labels. '''
                     '''Make sure the passed template includes formatting syntax such as {{}} where the label should go.'''
                 ).format(__lowercase      )      )

       if isinstance(__lowercase					,      __lowercase      ):
             SCREAMING_SNAKE_CASE__     :				List[Any]									=[sequences]

       SCREAMING_SNAKE_CASE__     :				Any									=[]
       for sequence in sequences:
             sequence_pairs.extend([[sequence, hypothesis_template.format(__lowercase      )] for label in labels]      )

       return sequence_pairs, sequences






@add_end_docstrings(lowerCamelCase				)
class      __SCREAMING_SNAKE_CASE      (			lowerCamelCase				):




 def __init__(      self	:							Optional[Any]					,      __lowercase	:							Tuple=ZeroShotClassificationArgumentHandler()					,      *__lowercase	:							Optional[Any]					,      **__lowercase	:							Any      )	->						int:
       SCREAMING_SNAKE_CASE__     :				Dict									=args_parser
       super().__init__(*__lowercase					,      **__lowercase      )
       if self.entailment_id == -1:
             logger.warning(
                 '''Failed to determine \'entailment\' label id from the label2id mapping in the model config. Setting to '''
                 '''-1. Define a descriptive label2id mapping in the model config to ensure correct outputs.'''      )




 @property
 def      __magic_name__	(      self	:							str      )	->						Union[str, Any]:
       for label, ind in self.model.config.labelaid.items():
             if label.lower().startswith('''entail'''      ):
                   return ind
       return -1




 def      __magic_name__	(      self	:							int					,      __lowercase	:							Dict					,      __lowercase	:							Dict=True					,      __lowercase	:							List[str]=True					,      __lowercase	:							Optional[int]=TruncationStrategy.ONLY_FIRST					,      **__lowercase	:							Tuple      )	->						Union[str, Any]:
       SCREAMING_SNAKE_CASE__     :				int									=self.framework
       if self.tokenizer.pad_token is None:
             # Override for tokenizers not supporting padding
             logger.error(
                 '''Tokenizer was not supporting padding necessary for zero-shot, attempting to use '''
                 ''' `pad_token=eos_token`'''      )
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=self.tokenizer.eos_token
       try:
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=self.tokenizer(
                 __lowercase					,      add_special_tokens=__lowercase					,      return_tensors=__lowercase					,      padding=__lowercase					,      truncation=__lowercase					,      )
       except Exception as e:
             if "too short" in str(__lowercase      ):
                   # tokenizers might yell that we want to truncate
                   # to a value that is not even reached by the input.
                   # In that case we don't want to truncate.
                   # It seems there's not a really better way to catch that
                   # exception.

                   SCREAMING_SNAKE_CASE__     :				Any									=self.tokenizer(
                       __lowercase					,      add_special_tokens=__lowercase					,      return_tensors=__lowercase					,      padding=__lowercase					,      truncation=TruncationStrategy.DO_NOT_TRUNCATE					,      )
             else:
                   raise e

       return inputs




 def      __magic_name__	(      self	:							List[Any]					,      **__lowercase	:							List[str]      )	->						Optional[Any]:
       if kwargs.get('''multi_class'''					,      __lowercase      ) is not None:
             SCREAMING_SNAKE_CASE__     :				Any									=kwargs['''multi_class''']
             logger.warning(
                 '''The `multi_class` argument has been deprecated and renamed to `multi_label`. '''
                 '''`multi_class` will be removed in a future version of Transformers.'''      )
       SCREAMING_SNAKE_CASE__     :				Any									={}
       if "candidate_labels" in kwargs:
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=self._args_parser._parse_labels(kwargs['''candidate_labels''']      )
       if "hypothesis_template" in kwargs:
             SCREAMING_SNAKE_CASE__     :				str									=kwargs['''hypothesis_template''']

       SCREAMING_SNAKE_CASE__     :				Tuple									={}
       if "multi_label" in kwargs:
             SCREAMING_SNAKE_CASE__     :				Any									=kwargs['''multi_label''']
       return preprocess_params, {}, postprocess_params




 def __call__(      self	:							Union[str, Any]					,      __lowercase	:							Union[str, List[str]]					,      *__lowercase	:							List[Any]					,      **__lowercase	:							List[Any]					,      )	->						Tuple:
       if len(__lowercase      ) == 0:
             pass
       elif len(__lowercase      ) == 1 and "candidate_labels" not in kwargs:
             SCREAMING_SNAKE_CASE__     :				Dict									=args[0]
       else:
             raise ValueError(F"Unable to understand extra arguments {args}"      )

       return super().__call__(__lowercase					,      **__lowercase      )




 def      __magic_name__	(      self	:							Tuple					,      __lowercase	:							Optional[Any]					,      __lowercase	:							Any=None					,      __lowercase	:							Any="This example is {}."      )	->						Union[str, Any]:
       SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__     :				Optional[Any]									=self._args_parser(__lowercase					,      __lowercase					,      __lowercase      )

       for i, (candidate_label, sequence_pair) in enumerate(zip(__lowercase					,      __lowercase      )      ):
             SCREAMING_SNAKE_CASE__     :				str									=self._parse_and_tokenize([sequence_pair]      )

             yield {
                 "candidate_label": candidate_label,
                 "sequence": sequences[0],
                 "is_last": i == len(__lowercase      ) - 1,
                 **model_input,
             }




 def      __magic_name__	(      self	:							Tuple					,      __lowercase	:							Optional[Any]      )	->						Optional[int]:
       SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=inputs['''candidate_label''']
       SCREAMING_SNAKE_CASE__     :				str									=inputs['''sequence''']
       SCREAMING_SNAKE_CASE__     :				List[Any]									={k: inputs[k] for k in self.tokenizer.model_input_names}
       SCREAMING_SNAKE_CASE__     :				Any									=self.model(**__lowercase      )

       SCREAMING_SNAKE_CASE__     :				Optional[int]									={
           '''candidate_label''': candidate_label,
           '''sequence''': sequence,
           '''is_last''': inputs['''is_last'''],
           **outputs,
       }
       return model_outputs




 def      __magic_name__	(      self	:							str					,      __lowercase	:							Dict					,      __lowercase	:							Union[str, Any]=False      )	->						int:
       SCREAMING_SNAKE_CASE__     :				List[str]									=[outputs['''candidate_label'''] for outputs in model_outputs]
       SCREAMING_SNAKE_CASE__     :				List[str]									=[outputs['''sequence'''] for outputs in model_outputs]
       SCREAMING_SNAKE_CASE__     :				Dict									=np.concatenate([output['''logits'''].numpy() for output in model_outputs]      )
       SCREAMING_SNAKE_CASE__     :				List[str]									=logits.shape[0]
       SCREAMING_SNAKE_CASE__     :				Tuple									=len(__lowercase      )
       SCREAMING_SNAKE_CASE__     :				List[Any]									=N // n
       SCREAMING_SNAKE_CASE__     :				Dict									=logits.reshape((num_sequences, n, -1)      )

       if multi_label or len(__lowercase      ) == 1:
             # softmax over the entailment vs. contradiction dim for each label independently
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=self.entailment_id
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=-1 if entailment_id == 0 else 0
             SCREAMING_SNAKE_CASE__     :				Any									=reshaped_outputs[..., [contradiction_id, entailment_id]]
             SCREAMING_SNAKE_CASE__     :				Any									=np.exp(__lowercase      ) / np.exp(__lowercase      ).sum(-1					,      keepdims=__lowercase      )
             SCREAMING_SNAKE_CASE__     :				Dict									=scores[..., 1]
       else:
             # softmax the "entailment" logits over all candidate labels
             SCREAMING_SNAKE_CASE__     :				int									=reshaped_outputs[..., self.entailment_id]
             SCREAMING_SNAKE_CASE__     :				List[Any]									=np.exp(__lowercase      ) / np.exp(__lowercase      ).sum(-1					,      keepdims=__lowercase      )

       SCREAMING_SNAKE_CASE__     :				Any									=list(reversed(scores[0].argsort()      )      )
       return {
           "sequence": sequences[0],
           "labels": [candidate_labels[i] for i in top_inds],
           "scores": scores[0, top_inds].tolist(),
       }







'''simple docstring'''
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


a_					= logging.get_logger(__name__)

a_					= {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

a_					= {
    'vocab_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/vocab.txt',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/vocab.txt',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'
        ),
        'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt',
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'
        ),
        'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt',
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'
        ),
        'bert-base-multilingual-cased': (
            'https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-cased': (
            'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'
        ),
    },
}

a_					= {
    'bert-base-uncased': 5_1_2,
    'bert-large-uncased': 5_1_2,
    'bert-base-cased': 5_1_2,
    'bert-large-cased': 5_1_2,
    'bert-base-multilingual-uncased': 5_1_2,
    'bert-base-multilingual-cased': 5_1_2,
    'bert-base-chinese': 5_1_2,
    'bert-base-german-cased': 5_1_2,
    'bert-large-uncased-whole-word-masking': 5_1_2,
    'bert-large-cased-whole-word-masking': 5_1_2,
    'bert-large-uncased-whole-word-masking-finetuned-squad': 5_1_2,
    'bert-large-cased-whole-word-masking-finetuned-squad': 5_1_2,
    'bert-base-cased-finetuned-mrpc': 5_1_2,
    'bert-base-german-dbmdz-cased': 5_1_2,
    'bert-base-german-dbmdz-uncased': 5_1_2,
    'TurkuNLP/bert-base-finnish-cased-v1': 5_1_2,
    'TurkuNLP/bert-base-finnish-uncased-v1': 5_1_2,
    'wietsedv/bert-base-dutch-cased': 5_1_2,
}

a_					= {
    'bert-base-uncased': {'do_lower_case': True},
    'bert-large-uncased': {'do_lower_case': True},
    'bert-base-cased': {'do_lower_case': False},
    'bert-large-cased': {'do_lower_case': False},
    'bert-base-multilingual-uncased': {'do_lower_case': True},
    'bert-base-multilingual-cased': {'do_lower_case': False},
    'bert-base-chinese': {'do_lower_case': False},
    'bert-base-german-cased': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking-finetuned-squad': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking-finetuned-squad': {'do_lower_case': False},
    'bert-base-cased-finetuned-mrpc': {'do_lower_case': False},
    'bert-base-german-dbmdz-cased': {'do_lower_case': False},
    'bert-base-german-dbmdz-uncased': {'do_lower_case': True},
    'TurkuNLP/bert-base-finnish-cased-v1': {'do_lower_case': False},
    'TurkuNLP/bert-base-finnish-uncased-v1': {'do_lower_case': True},
    'wietsedv/bert-base-dutch-cased': {'do_lower_case': False},
}






class      __SCREAMING_SNAKE_CASE      (			lowerCamelCase				):
 snake_case_  							=							VOCAB_FILES_NAMES
 snake_case_  							=							PRETRAINED_VOCAB_FILES_MAP
 snake_case_  							=							PRETRAINED_INIT_CONFIGURATION
 snake_case_  							=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 snake_case_  							=							BertTokenizer




 def __init__(      self	:							int					,      __lowercase	:							Union[str, Any]=None					,      __lowercase	:							Tuple=None					,      __lowercase	:							str=True					,      __lowercase	:							Optional[Any]="[UNK]"					,      __lowercase	:							Tuple="[SEP]"					,      __lowercase	:							Any="[PAD]"					,      __lowercase	:							List[Any]="[CLS]"					,      __lowercase	:							Union[str, Any]="[MASK]"					,      __lowercase	:							Tuple=True					,      __lowercase	:							str=None					,      **__lowercase	:							Any					,      )	->						Optional[Any]:
       super().__init__(
           __lowercase					,      tokenizer_file=__lowercase					,      do_lower_case=__lowercase					,      unk_token=__lowercase					,      sep_token=__lowercase					,      pad_token=__lowercase					,      cls_token=__lowercase					,      mask_token=__lowercase					,      tokenize_chinese_chars=__lowercase					,      strip_accents=__lowercase					,      **__lowercase					,      )

       SCREAMING_SNAKE_CASE__     :				str									=json.loads(self.backend_tokenizer.normalizer.__getstate__()      )
       if (
           normalizer_state.get('''lowercase'''					,      __lowercase      ) != do_lower_case
           or normalizer_state.get('''strip_accents'''					,      __lowercase      ) != strip_accents
           or normalizer_state.get('''handle_chinese_chars'''					,      __lowercase      ) != tokenize_chinese_chars
       ):
             SCREAMING_SNAKE_CASE__     :				int									=getattr(__lowercase					,      normalizer_state.pop('''type'''      )      )
             SCREAMING_SNAKE_CASE__     :				Any									=do_lower_case
             SCREAMING_SNAKE_CASE__     :				Any									=strip_accents
             SCREAMING_SNAKE_CASE__     :				Dict									=tokenize_chinese_chars
             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=normalizer_class(**__lowercase      )

       SCREAMING_SNAKE_CASE__     :				Optional[int]									=do_lower_case




 def      __magic_name__	(      self	:							int					,      __lowercase	:							Optional[Any]					,      __lowercase	:							Union[str, Any]=None      )	->						int:
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=[self.cls_token_id] + token_ids_a + [self.sep_token_id]

       if token_ids_a:
             output += token_ids_a + [self.sep_token_id]

       return output




 def      __magic_name__	(      self	:							Union[str, Any]					,      __lowercase	:							List[int]					,      __lowercase	:							Optional[List[int]] = None      )	->						List[int]:
       SCREAMING_SNAKE_CASE__     :				List[str]									=[self.sep_token_id]
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=[self.cls_token_id]
       if token_ids_a is None:
             return len(cls + token_ids_a + sep      ) * [0]
       return len(cls + token_ids_a + sep      ) * [0] + len(token_ids_a + sep      ) * [1]




 def      __magic_name__	(      self	:							List[Any]					,      __lowercase	:							str					,      __lowercase	:							Optional[str] = None      )	->						Tuple[str]:
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=self._tokenizer.model.save(__lowercase					,      name=__lowercase      )
       return tuple(__lowercase      )