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


_lowerCamelCase   :				str     			=						logging.get_logger(__name__)


class   lowercase      (       a       ):




							def 		__snake_case(  self				:   List[str]		,							_UpperCamelCase				:   Optional[Any] )   ->			List[Any]:



												'''simple docstring'''

												if isinstance(_UpperCamelCase		,							_UpperCamelCase ):
																	SCREAMING_SNAKE_CASE           =    [label.strip() for label in labels.split("," ) if label.strip()]
												return labels





							def __call__(  self				:   List[Any]		,							_UpperCamelCase				:   List[str]		,							_UpperCamelCase				:   Any		,							_UpperCamelCase				:   Dict )   ->			List[str]:



												'''simple docstring'''

												if len(_UpperCamelCase ) == 0 or len(_UpperCamelCase ) == 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(_UpperCamelCase ) )

												if isinstance(_UpperCamelCase		,							_UpperCamelCase ):
																	SCREAMING_SNAKE_CASE           =    [sequences]

												SCREAMING_SNAKE_CASE           =    []
												for sequence in sequences:
																	sequence_pairs.extend([[sequence, hypothesis_template.format(_UpperCamelCase )] for label in labels] )

												return sequence_pairs, sequences



@add_end_docstrings(a       )
class   lowercase      (       a       ):




							def __init__(  self				:   Union[str, Any]		,							_UpperCamelCase				:   List[str]=ZeroShotClassificationArgumentHandler()		,							*_UpperCamelCase				:   str		,							**_UpperCamelCase				:   Any )   ->			Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    args_parser
												super().__init__(*_UpperCamelCase		,							**_UpperCamelCase )
												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				:   Union[str, Any] )   ->			List[str]:



												'''simple docstring'''

												for label, ind in self.model.config.labelaid.items():
																	if label.lower().startswith("entail" ):
																						return ind
												return -1




							def 		__snake_case(  self				:   Union[str, Any]		,							_UpperCamelCase				:   Union[str, Any]		,							_UpperCamelCase				:   Dict=True		,							_UpperCamelCase				:   Dict=True		,							_UpperCamelCase				:   Optional[int]=TruncationStrategy.ONLY_FIRST		,							**_UpperCamelCase				:   Dict )   ->			int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    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           =    self.tokenizer.eos_token
												try:
																	SCREAMING_SNAKE_CASE           =    self.tokenizer(
																	    _UpperCamelCase		,							add_special_tokens=_UpperCamelCase		,							return_tensors=_UpperCamelCase		,							padding=_UpperCamelCase		,							truncation=_UpperCamelCase		,							)
												except Exception as e:
																	if "too short" in str(_UpperCamelCase ):
																						# 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           =    self.tokenizer(
																						    _UpperCamelCase		,							add_special_tokens=_UpperCamelCase		,							return_tensors=_UpperCamelCase		,							padding=_UpperCamelCase		,							truncation=TruncationStrategy.DO_NOT_TRUNCATE		,							)
																	else:
																						raise e

												return inputs




							def 		__snake_case(  self				:   str		,							**_UpperCamelCase				:   Any )   ->			Optional[Any]:



												'''simple docstring'''

												if kwargs.get("multi_class"		,							_UpperCamelCase ) is not None:
																	SCREAMING_SNAKE_CASE           =    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           =    {}
												if "candidate_labels" in kwargs:
																	SCREAMING_SNAKE_CASE           =    self._args_parser._parse_labels(kwargs["candidate_labels"] )
												if "hypothesis_template" in kwargs:
																	SCREAMING_SNAKE_CASE           =    kwargs["hypothesis_template"]

												SCREAMING_SNAKE_CASE           =    {}
												if "multi_label" in kwargs:
																	SCREAMING_SNAKE_CASE           =    kwargs["multi_label"]
												return preprocess_params, {}, postprocess_params




							def __call__(  self				:   List[Any]		,							_UpperCamelCase				:   Union[str, List[str]]		,							*_UpperCamelCase				:   List[str]		,							**_UpperCamelCase				:   int		,							)   ->			int:



												'''simple docstring'''

												if len(_UpperCamelCase ) == 0:
																	pass
												elif len(_UpperCamelCase ) == 1 and "candidate_labels" not in kwargs:
																	SCREAMING_SNAKE_CASE           =    args[0]
												else:
																	raise ValueError(F"Unable to understand extra arguments {args}" )

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




							def 		__snake_case(  self				:   int		,							_UpperCamelCase				:   Any		,							_UpperCamelCase				:   List[str]=None		,							_UpperCamelCase				:   str="This example is {}." )   ->			str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE     ,				SCREAMING_SNAKE_CASE           =    self._args_parser(_UpperCamelCase		,							_UpperCamelCase		,							_UpperCamelCase )

												for i, (candidate_label, sequence_pair) in enumerate(zip(_UpperCamelCase		,							_UpperCamelCase ) ):
																	SCREAMING_SNAKE_CASE           =    self._parse_and_tokenize([sequence_pair] )

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




							def 		__snake_case(  self				:   List[Any]		,							_UpperCamelCase				:   Union[str, Any] )   ->			Tuple:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    inputs["candidate_label"]
												SCREAMING_SNAKE_CASE           =    inputs["sequence"]
												SCREAMING_SNAKE_CASE           =    {k: inputs[k] for k in self.tokenizer.model_input_names}
												SCREAMING_SNAKE_CASE           =    self.model(**_UpperCamelCase )

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





							def 		__snake_case(  self				:   List[Any]		,							_UpperCamelCase				:   int		,							_UpperCamelCase				:   Any=False )   ->			Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    [outputs["candidate_label"] for outputs in model_outputs]
												SCREAMING_SNAKE_CASE           =    [outputs["sequence"] for outputs in model_outputs]
												SCREAMING_SNAKE_CASE           =    np.concatenate([output["logits"].numpy() for output in model_outputs] )
												SCREAMING_SNAKE_CASE           =    logits.shape[0]
												SCREAMING_SNAKE_CASE           =    len(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    N // n
												SCREAMING_SNAKE_CASE           =    logits.reshape((num_sequences, n, -1) )

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

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





from pickle import UnpicklingError

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict

from ..utils import logging


_lowerCamelCase   :				Optional[Any]     			=						logging.get_logger(__name__)





def 		__lowerCamelCase							(UpperCAmelCase__       :							str ,	UpperCAmelCase__       :							Dict					):
					try:
										with open(UpperCAmelCase__ ,	"rb"					) as flax_state_f:
															SCREAMING_SNAKE_CASE           =    from_bytes(UpperCAmelCase__ ,	flax_state_f.read()					)
					except UnpicklingError as e:
										try:
															with open(UpperCAmelCase__					) as f:
																				if f.read().startswith("version"					):
																									raise OSError(
																									    "You seem to have cloned a repository without having git-lfs installed. Please"
																									    " install git-lfs and run `git lfs install` followed by `git lfs pull` in the"
																									    " folder you cloned."					)
																				else:
																									raise ValueError from e
										except (UnicodeDecodeError, ValueError):
															raise EnvironmentError(F"Unable to convert {model_file} to Flax deserializable object. "					)

					return load_flax_weights_in_pytorch_model(UpperCAmelCase__ ,	UpperCAmelCase__					)





def 		__lowerCamelCase							(UpperCAmelCase__       :							int ,	UpperCAmelCase__       :							Optional[Any]					):

					try:
										import torch  # noqa: F401
					except ImportError:
										logger.error(
										    "Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see"
										    " https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"
										    " instructions."					)
										raise

					# check if we have bf16 weights
					SCREAMING_SNAKE_CASE           =    flatten_dict(jax.tree_util.tree_map(lambda UpperCAmelCase__					: x.dtype == jnp.bfloataa ,	UpperCAmelCase__					)					).values()
					if any(UpperCAmelCase__					):
										# convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

										# and bf16 is not fully supported in PT yet.
										logger.warning(
										    "Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` "
										    "before loading those in PyTorch model."					)
										SCREAMING_SNAKE_CASE           =    jax.tree_util.tree_map(
										    lambda UpperCAmelCase__					: params.astype(np.floataa					) if params.dtype == jnp.bfloataa else params ,	UpperCAmelCase__					)

					SCREAMING_SNAKE_CASE           =    ""

					SCREAMING_SNAKE_CASE           =    flatten_dict(UpperCAmelCase__ ,	sep="."					)
					SCREAMING_SNAKE_CASE           =    pt_model.state_dict()

					# keep track of unexpected & missing keys
					SCREAMING_SNAKE_CASE           =    []
					SCREAMING_SNAKE_CASE           =    set(pt_model_dict.keys()					)

					for flax_key_tuple, flax_tensor in flax_state_dict.items():
										SCREAMING_SNAKE_CASE           =    flax_key_tuple.split("."					)

										if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
															SCREAMING_SNAKE_CASE           =    flax_key_tuple_array[:-1] + ["weight"]
															SCREAMING_SNAKE_CASE           =    jnp.transpose(UpperCAmelCase__ ,	(3, 2, 0, 1)					)
										elif flax_key_tuple_array[-1] == "kernel":
															SCREAMING_SNAKE_CASE           =    flax_key_tuple_array[:-1] + ["weight"]
															SCREAMING_SNAKE_CASE           =    flax_tensor.T
										elif flax_key_tuple_array[-1] == "scale":
															SCREAMING_SNAKE_CASE           =    flax_key_tuple_array[:-1] + ["weight"]

										if "time_embedding" not in flax_key_tuple_array:
															for i, flax_key_tuple_string in enumerate(UpperCAmelCase__					):
																				SCREAMING_SNAKE_CASE           =    (
																				    flax_key_tuple_string.replace("_0" ,	".0"					)
																				    .replace("_1" ,	".1"					)
																				    .replace("_2" ,	".2"					)
																				    .replace("_3" ,	".3"					)
																				    .replace("_4" ,	".4"					)
																				    .replace("_5" ,	".5"					)
																				    .replace("_6" ,	".6"					)
																				    .replace("_7" ,	".7"					)
																				    .replace("_8" ,	".8"					)
																				    .replace("_9" ,	".9"					)
																				)

										SCREAMING_SNAKE_CASE           =    ".".join(UpperCAmelCase__					)

										if flax_key in pt_model_dict:
															if flax_tensor.shape != pt_model_dict[flax_key].shape:
																				raise ValueError(
																				    F"Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected "
																				    F"to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}."					)
															else:
																				# add weight to pytorch dict
																				SCREAMING_SNAKE_CASE           =    np.asarray(UpperCAmelCase__					) if not isinstance(UpperCAmelCase__ ,	np.ndarray					) else flax_tensor
																				SCREAMING_SNAKE_CASE           =    torch.from_numpy(UpperCAmelCase__					)
																				# remove from missing keys
																				missing_keys.remove(UpperCAmelCase__					)
										else:
															# weight is not expected by PyTorch model
															unexpected_keys.append(UpperCAmelCase__					)

					pt_model.load_state_dict(UpperCAmelCase__					)

					# re-transform missing_keys to list
					SCREAMING_SNAKE_CASE           =    list(UpperCAmelCase__					)

					if len(UpperCAmelCase__					) > 0:
										logger.warning(
										    "Some weights of the Flax model were not used when initializing the PyTorch model"
										    F" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing"
										    F" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture"
										    " (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"
										    F" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect"
										    " to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"
										    " FlaxBertForSequenceClassification model)."					)
					if len(UpperCAmelCase__					) > 0:
										logger.warning(
										    F"Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly"
										    F" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to"
										    " use it for predictions and inference."					)

					return pt_model




