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

_UpperCamelCase								=		logging.get_logger(__name__)
class 						__UpperCAmelCase    (enum.Enum     ):







			'''simple docstring'''
			_UpperCamelCase  :						List[Any]					     =				0
			_UpperCamelCase  :						List[Any]					     =				1





@add_end_docstrings(__A     )
class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''
			_UpperCamelCase  :						Dict					     =				'generated'





			def __init__(			self   ,      *snake_case_   ,      **snake_case_							):







										'''simple docstring'''


										super().__init__(*snake_case_   ,      **snake_case_							)

										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 		lowerCamelCase					(			self   ,      snake_case_=None   ,      snake_case_=None   ,      snake_case_=None   ,      snake_case_=None   ,      snake_case_=None   ,      snake_case_=None   ,      **snake_case_   ,      ):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			{}
										if truncation is not None:
																	A__       :     Optional[int]								=			truncation

										A__       :     Optional[Any]								=			generate_kwargs

										A__       :     Optional[int]								=			{}
										if return_tensors is not None and return_type is None:
																	A__       :     int								=			ReturnType.TENSORS if return_tensors else ReturnType.TEXT
										if return_type is not None:
																	A__       :     Tuple								=			return_type

										if clean_up_tokenization_spaces is not None:
																	A__       :     Tuple								=			clean_up_tokenization_spaces

										if stop_sequence is not None:
																	A__       :     List[str]								=			self.tokenizer.encode(snake_case_   ,      add_special_tokens=snake_case_							)
																	if len(snake_case_							) > 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."""							)
																	A__       :     Dict								=			stop_sequence_ids[0]

										return preprocess_params, forward_params, postprocess_params





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										return True





			def 		lowerCamelCase					(			self   ,      *snake_case_   ,      snake_case_							):







										'''simple docstring'''


										A__       :     Dict								=			self.model.config.prefix if self.model.config.prefix is not None else """"""
										if isinstance(args[0]   ,      snake_case_							):
																	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"""							)
																	A__       :     List[str]								=			([prefix + arg for arg in args[0]],)
																	A__       :     Any								=			True

										elif isinstance(args[0]   ,      snake_case_							):
																	A__       :     Any								=			(prefix + args[0],)
																	A__       :     Optional[int]								=			False
										else:
																	raise ValueError(
																	    F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''							)
										A__       :     int								=			self.tokenizer(*snake_case_   ,      padding=snake_case_   ,      truncation=snake_case_   ,      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   ,      *snake_case_   ,      **snake_case_							):







										'''simple docstring'''


										A__       :     Optional[int]								=			super().__call__(*snake_case_   ,      **snake_case_							)
										if (
										    isinstance(args[0]   ,      snake_case_							)
										    and all(isinstance(snake_case_   ,      snake_case_							) for el in args[0]							)
										    and all(len(snake_case_							) == 1 for res in result							)
										):
																	return [res[0] for res in result]
										return result





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_=TruncationStrategy.DO_NOT_TRUNCATE   ,      **snake_case_							):







										'''simple docstring'''


										A__       :     Optional[int]								=			self._parse_and_tokenize(snake_case_   ,      truncation=snake_case_   ,      **snake_case_							)
										return inputs





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      **snake_case_							):







										'''simple docstring'''


										if self.framework == "pt":
																	A__				,							A__       :     Union[str, Any]								=			model_inputs["""input_ids"""].shape
										elif self.framework == "tf":
																	A__				,							A__       :     Any								=			tf.shape(model_inputs["""input_ids"""]							).numpy()

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





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_=ReturnType.TEXT   ,      snake_case_=False							):







										'''simple docstring'''


										A__       :     int								=			[]
										for output_ids in model_outputs["output_ids"][0]:
																	if return_type == ReturnType.TENSORS:
																								A__       :     Tuple								=			{F'''{self.return_name}_token_ids''': output_ids}
																	elif return_type == ReturnType.TEXT:
																								A__       :     int								=			{
																								    F'''{self.return_name}_text''': self.tokenizer.decode(
																								        snake_case_   ,      skip_special_tokens=snake_case_   ,      clean_up_tokenization_spaces=snake_case_   ,      )
																								}
																	records.append(snake_case_							)
										return records





@add_end_docstrings(__A     )
class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''
			_UpperCamelCase  :						Union[str, Any]					     =				'summary'





			def __call__(			self   ,      *snake_case_   ,      **snake_case_							):







										'''simple docstring'''


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





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										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(__A     )
class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''
			_UpperCamelCase  :						Optional[Any]					     =				'translation'





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										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 		lowerCamelCase					(			self   ,      *snake_case_   ,      snake_case_=TruncationStrategy.DO_NOT_TRUNCATE   ,      snake_case_=None   ,      snake_case_=None							):







										'''simple docstring'''


										if getattr(self.tokenizer   ,      """_build_translation_inputs"""   ,      snake_case_							):
																	return self.tokenizer._build_translation_inputs(
																	    *snake_case_   ,      return_tensors=self.framework   ,      truncation=snake_case_   ,      src_lang=snake_case_   ,      tgt_lang=snake_case_							)
										else:
																	return super()._parse_and_tokenize(*snake_case_   ,      truncation=snake_case_							)





			def 		lowerCamelCase					(			self   ,      snake_case_=None   ,      snake_case_=None   ,      **snake_case_							):







										'''simple docstring'''


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





			def __call__(			self   ,      *snake_case_   ,      **snake_case_							):







										'''simple docstring'''


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






"""simple docstring"""



from typing import List

from .keymap import KEYMAP, get_character

def  _A(		lowerCAmelCase							):

							def decorator(lowerCAmelCase							):
														A__       :     Any								=			getattr(lowerCAmelCase			,  """handle_key"""			,  []							)
														handle += [key]
														setattr(lowerCAmelCase			,  """handle_key"""			,  lowerCAmelCase							)
														return func

							return decorator

def  _A(		*lowerCAmelCase							):

							def decorator(lowerCAmelCase							):
														A__       :     Optional[Any]								=			getattr(lowerCAmelCase			,  """handle_key"""			,  []							)
														handle += keys
														setattr(lowerCAmelCase			,  """handle_key"""			,  lowerCAmelCase							)
														return func

							return decorator
class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''





			def __new__(			cls   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			super().__new__(cls   ,      snake_case_   ,      snake_case_   ,      snake_case_							)
										if not hasattr(snake_case_   ,      """key_handler"""							):
																	setattr(snake_case_   ,      """key_handler"""   ,      {}							)
										setattr(snake_case_   ,      """handle_input"""   ,      KeyHandler.handle_input							)

										for value in attrs.values():
																	A__       :     Dict								=			getattr(snake_case_   ,      """handle_key"""   ,      []							)
																	for key in handled_keys:
																								A__       :     Optional[Any]								=			value
										return new_cls





			@staticmethod
			def 		lowerCamelCase					(			cls							):







										'''simple docstring'''


										A__       :     int								=			get_character()
										if char != KEYMAP["undefined"]:
																	A__       :     Union[str, Any]								=			ord(snake_case_							)
										A__       :     int								=			cls.key_handler.get(snake_case_							)
										if handler:
																	A__       :     int								=			char
																	return handler(cls							)
										else:
																	return None





def  _A(		cls							):
							return KeyHandler(cls.__name__			,  cls.__bases__			,  cls.__dict__.copy()							)





