





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

lowerCamelCase_       =		logging.get_logger(__name__)






class  _SCREAMING_SNAKE_CASE(       enum.Enum  ):
       SCREAMING_SNAKE_CASE_       :				List[Any]     						=  0
       SCREAMING_SNAKE_CASE_       :				Tuple     						=  1






@add_end_docstrings(A  )
class  _SCREAMING_SNAKE_CASE(       A  ):
       SCREAMING_SNAKE_CASE_       :				Any     						=  '''generated'''




       def __init__(						self		,*SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)      ->				Tuple:





             """simple docstring"""






             super().__init__(*SCREAMING_SNAKE_CASE__		,**SCREAMING_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    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None		,**SCREAMING_SNAKE_CASE__		,)      ->				List[str]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  {}
             if truncation is not None:
                   __SCREAMING_SNAKE_CASE       :List[Any]		    =  truncation

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  generate_kwargs

             __SCREAMING_SNAKE_CASE       :List[str]		    =  {}
             if return_tensors is not None and return_type is None:
                   __SCREAMING_SNAKE_CASE       :Dict		    =  ReturnType.TENSORS if return_tensors else ReturnType.TEXT
             if return_type is not None:
                   __SCREAMING_SNAKE_CASE       :List[Any]		    =  return_type

             if clean_up_tokenization_spaces is not None:
                   __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  clean_up_tokenization_spaces

             if stop_sequence is not None:
                   __SCREAMING_SNAKE_CASE       :int		    =  self.tokenizer.encode(SCREAMING_SNAKE_CASE__		,add_special_tokens=SCREAMING_SNAKE_CASE__							)
                   if len(SCREAMING_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.'''							)
                   __SCREAMING_SNAKE_CASE       :Optional[int]		    =  stop_sequence_ids[0]

             return preprocess_params, forward_params, postprocess_params




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				Tuple:





             """simple docstring"""






             return True




       def    _UpperCamelCase					(						self		,*SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				Any:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  self.model.config.prefix if self.model.config.prefix is not None else ''''''
             if isinstance(args[0]		,SCREAMING_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'''							)
                   __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  ([prefix + arg for arg in args[0]],)
                   __SCREAMING_SNAKE_CASE       :Tuple		    =  True

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





             """simple docstring"""






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




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=TruncationStrategy.DO_NOT_TRUNCATE		,**SCREAMING_SNAKE_CASE__							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Dict		    =  self._parse_and_tokenize(SCREAMING_SNAKE_CASE__		,truncation=SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)
             return inputs




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)      ->				Dict:





             """simple docstring"""






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

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




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=ReturnType.TEXT		,SCREAMING_SNAKE_CASE__=False							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  []
             for output_ids in model_outputs["output_ids"][0]:
                   if return_type == ReturnType.TENSORS:
                         __SCREAMING_SNAKE_CASE       :Tuple		    =  {f'''{self.return_name}_token_ids''': output_ids}
                   elif return_type == ReturnType.TEXT:
                         __SCREAMING_SNAKE_CASE       :str		    =  {
                             f'''{self.return_name}_text''': self.tokenizer.decode(
                                 SCREAMING_SNAKE_CASE__		,skip_special_tokens=SCREAMING_SNAKE_CASE__		,clean_up_tokenization_spaces=SCREAMING_SNAKE_CASE__		,)
                         }
                   records.append(SCREAMING_SNAKE_CASE__							)
             return records






@add_end_docstrings(A  )
class  _SCREAMING_SNAKE_CASE(       A  ):
       SCREAMING_SNAKE_CASE_       :				Tuple     						=  '''summary'''




       def __call__(						self		,*SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)      ->				int:





             """simple docstring"""






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




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				bool:





             """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  _SCREAMING_SNAKE_CASE(       A  ):
       SCREAMING_SNAKE_CASE_       :				str     						=  '''translation'''




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				Tuple:





             """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    _UpperCamelCase					(						self		,*SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=TruncationStrategy.DO_NOT_TRUNCATE		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None							)      ->				int:





             """simple docstring"""






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




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=None		,**SCREAMING_SNAKE_CASE__							)      ->				List[Any]:





             """simple docstring"""






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




       def __call__(						self		,*SCREAMING_SNAKE_CASE__		,**SCREAMING_SNAKE_CASE__							)      ->				List[Any]:





             """simple docstring"""






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






"""simple docstring"""
from torch import nn






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				List[str]:





             """simple docstring"""






             super().__init__()
             __SCREAMING_SNAKE_CASE       :Tuple		    =  class_size
             __SCREAMING_SNAKE_CASE       :str		    =  embed_size
             # self.mlp1 = nn.Linear(embed_size, embed_size)
             # self.mlp2 = (nn.Linear(embed_size, class_size))
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  nn.Linear(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				Optional[int]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  self.mlp(SCREAMING_SNAKE_CASE__							)
             return logits