



"""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


_lowercase			:			List[Any]										=						logging.get_logger(__name__)

class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_       ):


     '''simple docstring'''





     def 		snake_case	(	self							:  Any,  lowerCamelCase							:  int					)-> Optional[Any]:
        if isinstance(lowerCamelCase,  lowerCamelCase					):
           lowerCamelCase__		:		Union[str, Any]		     =[label.strip() for label in labels.split(''','''					) if label.strip()]
        return labels




     def __call__(	self							:  Union[str, Any],  lowerCamelCase							:  Dict,  lowerCamelCase							:  Any,  lowerCamelCase							:  Optional[Any]					)-> Optional[int]:
        if len(lowerCamelCase					) == 0 or len(lowerCamelCase					) == 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(lowerCamelCase					)					)

        if isinstance(lowerCamelCase,  lowerCamelCase					):
           lowerCamelCase__		:		Tuple		     =[sequences]

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

        return sequence_pairs, sequences





@add_end_docstrings(lowerCAmelCase_       )
class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_       ):


     '''simple docstring'''





     def __init__(	self							:  List[str],  lowerCamelCase							:  Optional[Any]=ZeroShotClassificationArgumentHandler(),  *lowerCamelCase							:  Tuple,  **lowerCamelCase							:  List[str]					)-> int:
        lowerCamelCase__		:		Optional[Any]		     =args_parser
        super().__init__(*lowerCamelCase,  **lowerCamelCase					)
        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 		snake_case	(	self							:  List[Any]					)-> Union[str, Any]:
        for label, ind in self.model.config.labelaid.items():
           if label.lower().startswith('''entail'''					):
              return ind
        return -1



     def 		snake_case	(	self							:  Optional[int],  lowerCamelCase							:  int,  lowerCamelCase							:  Any=True,  lowerCamelCase							:  List[str]=True,  lowerCamelCase							:  int=TruncationStrategy.ONLY_FIRST,  **lowerCamelCase							:  List[Any]					)-> List[str]:
        lowerCamelCase__		:		Tuple		     =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`'''					)
           lowerCamelCase__		:		Any		     =self.tokenizer.eos_token
        try:
           lowerCamelCase__		:		Tuple		     =self.tokenizer(
               lowerCamelCase,  add_special_tokens=lowerCamelCase,  return_tensors=lowerCamelCase,  padding=lowerCamelCase,  truncation=lowerCamelCase,  )
        except Exception as e:
           if "too short" in str(lowerCamelCase					):
              # 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.

              lowerCamelCase__		:		List[Any]		     =self.tokenizer(
                  lowerCamelCase,  add_special_tokens=lowerCamelCase,  return_tensors=lowerCamelCase,  padding=lowerCamelCase,  truncation=TruncationStrategy.DO_NOT_TRUNCATE,  )
           else:
              raise e

        return inputs



     def 		snake_case	(	self							:  int,  **lowerCamelCase							:  Tuple					)-> Any:
        if kwargs.get('''multi_class''',  lowerCamelCase					) is not None:
           lowerCamelCase__		:		Optional[int]		     =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.'''					)
        lowerCamelCase__		:		Any		     ={}
        if "candidate_labels" in kwargs:
           lowerCamelCase__		:		Dict		     =self._args_parser._parse_labels(kwargs['''candidate_labels''']					)
        if "hypothesis_template" in kwargs:
           lowerCamelCase__		:		Optional[Any]		     =kwargs['''hypothesis_template''']

        lowerCamelCase__		:		str		     ={}
        if "multi_label" in kwargs:
           lowerCamelCase__		:		Optional[Any]		     =kwargs['''multi_label''']
        return preprocess_params, {}, postprocess_params



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

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



     def 		snake_case	(	self							:  Any,  lowerCamelCase							:  List[str],  lowerCamelCase							:  Any=None,  lowerCamelCase							:  Optional[Any]="This example is {}."					)-> Tuple:
        lowerCamelCase__		:		List[str]		     =self._args_parser(lowerCamelCase,  lowerCamelCase,  lowerCamelCase					)

        for i, (candidate_label, sequence_pair) in enumerate(zip(lowerCamelCase,  lowerCamelCase					)					):
           lowerCamelCase__		:		Optional[Any]		     =self._parse_and_tokenize([sequence_pair]					)

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



     def 		snake_case	(	self							:  Optional[int],  lowerCamelCase							:  Optional[int]					)-> Union[str, Any]:
        lowerCamelCase__		:		Dict		     =inputs['''candidate_label''']
        lowerCamelCase__		:		Union[str, Any]		     =inputs['''sequence''']
        lowerCamelCase__		:		Any		     ={k: inputs[k] for k in self.tokenizer.model_input_names}
        lowerCamelCase__		:		Optional[Any]		     =self.model(**lowerCamelCase					)

        lowerCamelCase__		:		Union[str, Any]		     ={
            '''candidate_label''': candidate_label,
            '''sequence''': sequence,
            '''is_last''': inputs['''is_last'''],
            **outputs,
        }
        return model_outputs




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

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

        lowerCamelCase__		:		List[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"""






def 					snake_case__       (		__lowerCamelCase    :   int							,		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			return int((input_a, input_a).count(0     ) != 0     )






def 					snake_case__       (		):
			"""simple docstring"""
			assert nand_gate(0							,		0     ) == 1
			assert nand_gate(0							,		1     ) == 1
			assert nand_gate(1							,		0     ) == 1
			assert nand_gate(1							,		1     ) == 0


if __name__ == "__main__":
		print(nand_gate(0, 0))
		print(nand_gate(0, 1))
		print(nand_gate(1, 0))
		print(nand_gate(1, 1))




