'''simple docstring'''




import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
						import tensorflow as tf

						from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
						from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

_lowercase						: Any						=						logging.get_logger(__name__)





class     __magic_name__						(    enum.Enum):
			UpperCamelCase__				=       0
			UpperCamelCase__				=       1





@add_end_docstrings(_UpperCAmelCase)
class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''generated'''







			def __init__(	self				:  Dict				,			*lowercase_				:  Tuple				,			**lowercase_				:  Optional[Any]    ):
										super().__init__(*lowercase_				,			**lowercase_    )

										self.check_model_type(
										    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
										    if self.framework == """tf"""
										    else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  str				,			lowercase_				:  Tuple=None				,			lowercase_				:  Optional[Any]=None				,			lowercase_				:  Tuple=None				,			lowercase_				:  int=None				,			lowercase_				:  Optional[Any]=None				,			lowercase_				:  Optional[Any]=None				,			**lowercase_				:  List[Any]				,			):
										lowercase_					:			str										=       {}
										if truncation is not None:
																	lowercase_					:			Optional[Any]										=       truncation

										lowercase_					:			Dict										=       generate_kwargs

										lowercase_					:			Union[str, Any]										=       {}
										if return_tensors is not None and return_type is None:
																	lowercase_					:			List[Any]										=       ReturnType.TENSORS if return_tensors else ReturnType.TEXT
										if return_type is not None:
																	lowercase_					:			Optional[Any]										=       return_type

										if clean_up_tokenization_spaces is not None:
																	lowercase_					:			int										=       clean_up_tokenization_spaces

										if stop_sequence is not None:
																	lowercase_					:			Union[str, Any]										=       self.tokenizer.encode(lowercase_				,			add_special_tokens=lowercase_    )
																	if len(lowercase_    ) > 1:
																								warnings.warn(
																								    """Stopping on a multiple token sequence is not yet supported on transformers. The first token of"""
																								    """ the stop sequence will be used as the stop sequence string in the interim."""    )
																	lowercase_					:			Tuple										=       stop_sequence_ids[0]

										return preprocess_params, forward_params, postprocess_params







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Any				,			lowercase_				:  int				,			lowercase_				:  int				,			lowercase_				:  int    ):
										return True







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]				,			*lowercase_				:  List[Any]				,			lowercase_				:  str    ):
										lowercase_					:			Dict										=       self.model.config.prefix if self.model.config.prefix is not None else """"""
										if isinstance(args[0]				,			lowercase_    ):
																	if self.tokenizer.pad_token_id is None:
																								raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input"""    )
																	lowercase_					:			List[str]										=       ([prefix + arg for arg in args[0]],)
																	lowercase_					:			Dict										=       True

										elif isinstance(args[0]				,			lowercase_    ):
																	lowercase_					:			int										=       (prefix + args[0],)
																	lowercase_					:			List[str]										=       False
										else:
																	raise ValueError(
																	    f''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''    )
										lowercase_					:			Dict										=       self.tokenizer(*lowercase_				,			padding=lowercase_				,			truncation=lowercase_				,			return_tensors=self.framework    )
										# This is produced by tokenizers but is an invalid generate kwargs
										if "token_type_ids" in inputs:
																	del inputs["token_type_ids"]
										return inputs







			def __call__(	self				:  Any				,			*lowercase_				:  int				,			**lowercase_				:  Any    ):
										lowercase_					:			Any										=       super().__call__(*lowercase_				,			**lowercase_    )
										if (
										    isinstance(args[0]				,			lowercase_    )
										    and all(isinstance(lowercase_				,			lowercase_    ) for el in args[0]    )
										    and all(len(lowercase_    ) == 1 for res in result    )
										):
																	return [res[0] for res in result]
										return result







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Any				,			lowercase_				:  int				,			lowercase_				:  List[Any]=TruncationStrategy.DO_NOT_TRUNCATE				,			**lowercase_				:  str    ):
										lowercase_					:			List[str]										=       self._parse_and_tokenize(lowercase_				,			truncation=lowercase_				,			**lowercase_    )
										return inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Dict				,			lowercase_				:  Tuple				,			**lowercase_				:  Union[str, Any]    ):
										if self.framework == "pt":
																	lowercase_						,						lowercase_					:			Tuple										=       model_inputs["""input_ids"""].shape
										elif self.framework == "tf":
																	lowercase_						,						lowercase_					:			List[Any]										=       tf.shape(model_inputs["""input_ids"""]    ).numpy()

										lowercase_					:			Optional[Any]										=       generate_kwargs.get("""min_length"""				,			self.model.config.min_length    )
										lowercase_					:			Any										=       generate_kwargs.get("""max_length"""				,			self.model.config.max_length    )
										self.check_inputs(lowercase_				,			generate_kwargs["""min_length"""]				,			generate_kwargs["""max_length"""]    )
										lowercase_					:			Any										=       self.model.generate(**lowercase_				,			**lowercase_    )
										lowercase_					:			List[str]										=       output_ids.shape[0]
										if self.framework == "pt":
																	lowercase_					:			str										=       output_ids.reshape(lowercase_				,			out_b // in_b				,			*output_ids.shape[1:]    )
										elif self.framework == "tf":
																	lowercase_					:			Dict										=       tf.reshape(lowercase_				,			(in_b, out_b // in_b, *output_ids.shape[1:])    )
										return {"output_ids": output_ids}







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int				,			lowercase_				:  List[Any]				,			lowercase_				:  str=ReturnType.TEXT				,			lowercase_				:  List[Any]=False    ):
										lowercase_					:			Tuple										=       []
										for output_ids in model_outputs["output_ids"][0]:
																	if return_type == ReturnType.TENSORS:
																								lowercase_					:			str										=       {f'''{self.return_name}_token_ids''': output_ids}
																	elif return_type == ReturnType.TEXT:
																								lowercase_					:			Union[str, Any]										=       {
																								    f'''{self.return_name}_text''': self.tokenizer.decode(
																								        lowercase_				,			skip_special_tokens=lowercase_				,			clean_up_tokenization_spaces=lowercase_				,			)
																								}
																	records.append(lowercase_    )
										return records





@add_end_docstrings(_UpperCAmelCase)
class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''summary'''







			def __call__(	self				:  int				,			*lowercase_				:  List[str]				,			**lowercase_				:  Tuple    ):
										return super().__call__(*lowercase_				,			**lowercase_    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  str				,			lowercase_				:  int				,			lowercase_				:  int				,			lowercase_				:  int    ):
										if max_length < min_length:
																	logger.warning(f'''Your min_length={min_length} must be inferior than your max_length={max_length}.'''    )

										if input_length < max_length:
																	logger.warning(
																	    f'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
																	    """a summarization task, where outputs shorter than the input are typically wanted, you might """
																	    f'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})'''    )





@add_end_docstrings(_UpperCAmelCase)
class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''translation'''







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]				,			lowercase_				:  int				,			lowercase_				:  int				,			lowercase_				:  int    ):
										if input_length > 0.9 * max_length:
																	logger.warning(
																	    f'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
																	    """increasing your max_length manually, e.g. translator('...', max_length=400)"""    )
										return True







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[int]				,			*lowercase_				:  List[str]				,			lowercase_				:  Union[str, Any]=TruncationStrategy.DO_NOT_TRUNCATE				,			lowercase_				:  Any=None				,			lowercase_				:  Optional[Any]=None    ):
										if getattr(self.tokenizer				,			"""_build_translation_inputs"""				,			lowercase_    ):
																	return self.tokenizer._build_translation_inputs(
																	    *lowercase_				,			return_tensors=self.framework				,			truncation=lowercase_				,			src_lang=lowercase_				,			tgt_lang=lowercase_    )
										else:
																	return super()._parse_and_tokenize(*lowercase_				,			truncation=lowercase_    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]				,			lowercase_				:  List[str]=None				,			lowercase_				:  List[Any]=None				,			**lowercase_				:  str    ):
										lowercase_						,						lowercase_						,						lowercase_					:			Optional[int]										=       super()._sanitize_parameters(**lowercase_    )
										if src_lang is not None:
																	lowercase_					:			Dict										=       src_lang
										if tgt_lang is not None:
																	lowercase_					:			int										=       tgt_lang
										if src_lang is None and tgt_lang is None:
																	# Backward compatibility, direct arguments use is preferred.
																	lowercase_					:			Any										=       kwargs.get("""task"""				,			self.task    )
																	lowercase_					:			Optional[int]										=       task.split("""_"""    )
																	if task and len(lowercase_    ) == 4:
																								# translation, XX, to YY
																								lowercase_					:			str										=       items[1]
																								lowercase_					:			int										=       items[3]
										return preprocess_params, forward_params, postprocess_params







			def __call__(	self				:  Dict				,			*lowercase_				:  Union[str, Any]				,			**lowercase_				:  Optional[int]    ):
										return super().__call__(*lowercase_				,			**lowercase_    )






'''simple docstring'''




from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowercase						: Dict						=						{"configuration_mmbt": ["MMBTConfig"]}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowercase						: Dict						=						["MMBTForClassification", "MMBTModel", "ModalEmbeddings"]


if TYPE_CHECKING:
						from .configuration_mmbt import MMBTConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mmbt import MMBTForClassification, MMBTModel, ModalEmbeddings

else:
						import sys

						_lowercase						: Optional[int]						=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





