


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


_snake_case					:		str      =    logging.get_logger(__name__)

class     a		(_lowerCAmelCase				):




							"""simple docstring"""


							def    __snake_case (							self	:  Optional[int]   ,     lowerCamelCase	:  List[Any]    )     ->   Optional[int]:
														if isinstance(lowerCamelCase   ,     lowerCamelCase    ):
																					__snake_case		:      int										=       [label.strip() for label in labels.split(","    ) if label.strip()]
														return labels






							def __call__(							self	:  Optional[int]   ,     lowerCamelCase	:  Dict   ,     lowerCamelCase	:  str   ,     lowerCamelCase	:  Optional[int]    )     ->   Tuple:
														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    ):
																					__snake_case		:      List[str]										=       [sequences]

														__snake_case		:      Optional[int]										=       []
														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     a		(_lowerCAmelCase				):




							"""simple docstring"""


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

							def    __snake_case (							self	:  List[Any]   ,     lowerCamelCase	:  Any   ,     lowerCamelCase	:  Dict=True   ,     lowerCamelCase	:  Dict=True   ,     lowerCamelCase	:  int=TruncationStrategy.ONLY_FIRST   ,     **lowerCamelCase	:  Dict    )     ->   int:
														__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`"    )
																					__snake_case		:      Optional[Any]										=       self.tokenizer.eos_token
														try:
																					__snake_case		:      Optional[int]										=       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.

																												__snake_case		:      List[str]										=       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	:  Union[str, Any]   ,     **lowerCamelCase	:  Tuple    )     ->   Tuple:
														if kwargs.get("multi_class"   ,     lowerCamelCase    ) is not None:
																					__snake_case		:      Tuple										=       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."    )
														__snake_case		:      int										=       {}
														if "candidate_labels" in kwargs:
																					__snake_case		:      Union[str, Any]										=       self._args_parser._parse_labels(kwargs["candidate_labels"]    )
														if "hypothesis_template" in kwargs:
																					__snake_case		:      Tuple										=       kwargs["hypothesis_template"]

														__snake_case		:      Any										=       {}
														if "multi_label" in kwargs:
																					__snake_case		:      List[str]										=       kwargs["multi_label"]
														return preprocess_params, {}, postprocess_params

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

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

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

														for i, (candidate_label, sequence_pair) in enumerate(zip(lowerCamelCase   ,     lowerCamelCase    )    ):
																					__snake_case		:      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	:  Union[str, Any]   ,     lowerCamelCase	:  Tuple    )     ->   List[str]:
														__snake_case		:      str										=       inputs["candidate_label"]
														__snake_case		:      List[Any]										=       inputs["sequence"]
														__snake_case		:      Dict										=       {k: inputs[k] for k in self.tokenizer.model_input_names}
														__snake_case		:      Tuple										=       self.model(**lowerCamelCase    )

														__snake_case		:      int										=       {
														    "candidate_label": candidate_label,
														    "sequence": sequence,
														    "is_last": inputs["is_last"],
														    **outputs,
														}
														return model_outputs






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

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

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





def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							if index == r:
														for j in range(__lowerCamelCase     ):
																					print(data[j]							,     end=" "     )
														print(" "     )
														return
							#  When no more elements are there to put in data[]
							if i >= n:
														return
							# current is included, put next at next location
							__snake_case		:      Union[str, Any]										=       arr[i]
							combination_util(__lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     index + 1							,     __lowerCamelCase							,     i + 1     )
							# current is excluded, replace it with
							# next (Note that i+1 is passed, but
							# index is not changed)
							combination_util(__lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     i + 1     )
							# The main function that prints all combinations
							# of size r in arr[] of size n. This function
							# mainly uses combinationUtil()







def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							# A temporary array to store all combination one by one
							__snake_case		:      Union[str, Any]										=       [0] * r
							# Print all combination using temporary array 'data[]'
							combination_util(__lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     0							,     __lowerCamelCase							,     0     )


if __name__ == "__main__":
			# Driver code to check the function above
			_snake_case					:		List[str]      =    [10, 20, 30, 40, 50]
			print_combination(arr, len(arr), 3)
			# This code is contributed by Ambuj sahu

