


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

__snake_case    						=logging.get_logger(__name__)

class 		UpperCAmelCase_      (  enum.Enum		):
     lowerCamelCase				:	Optional[int]		=     0
     lowerCamelCase				:	str		=     1




@add_end_docstrings(__lowercase		)
class 		UpperCAmelCase_      (  __lowercase		):
     lowerCamelCase				:	Tuple		=     '''generated'''





     def __init__( self       :      Optional[int]    ,      *UpperCAmelCase__       :      Optional[Any]    ,      **UpperCAmelCase__       :      Optional[int]    )				->  Tuple:
        super().__init__(*UpperCAmelCase__    ,      **UpperCAmelCase__    )

        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       :      Dict    ,      UpperCAmelCase__       :      List[str]=None    ,      UpperCAmelCase__       :      Dict=None    ,      UpperCAmelCase__       :      List[str]=None    ,      UpperCAmelCase__       :      Tuple=None    ,      UpperCAmelCase__       :      Any=None    ,      UpperCAmelCase__       :      Dict=None    ,      **UpperCAmelCase__       :      List[str]    ,      )				->  Union[str, Any]:
        lowerCAmelCase     =			{}
        if truncation is not None:
           lowerCAmelCase     =			truncation

        lowerCAmelCase     =			generate_kwargs

        lowerCAmelCase     =			{}
        if return_tensors is not None and return_type is None:
           lowerCAmelCase     =			ReturnType.TENSORS if return_tensors else ReturnType.TEXT
        if return_type is not None:
           lowerCAmelCase     =			return_type

        if clean_up_tokenization_spaces is not None:
           lowerCAmelCase     =			clean_up_tokenization_spaces

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

        return preprocess_params, forward_params, postprocess_params





     def 							__UpperCAmelCase      ( self       :      List[Any]    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    )				->  List[Any]:
        return True





     def 							__UpperCAmelCase      ( self       :      Optional[int]    ,      *UpperCAmelCase__       :      Optional[int]    ,      UpperCAmelCase__       :      List[Any]    )				->  Optional[int]:
        lowerCAmelCase     =			self.model.config.prefix if self.model.config.prefix is not None else ''
        if isinstance(args[0]    ,      UpperCAmelCase__    ):
           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'    )
           lowerCAmelCase     =			([prefix + arg for arg in args[0]],)
           lowerCAmelCase     =			True

        elif isinstance(args[0]    ,      UpperCAmelCase__    ):
           lowerCAmelCase     =			(prefix + args[0],)
           lowerCAmelCase     =			False
        else:
           raise ValueError(
               F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''    )
        lowerCAmelCase     =			self.tokenizer(*UpperCAmelCase__    ,      padding=UpperCAmelCase__    ,      truncation=UpperCAmelCase__    ,      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       :      Optional[Any]    ,      *UpperCAmelCase__       :      List[Any]    ,      **UpperCAmelCase__       :      str    )				->  List[Any]:
        lowerCAmelCase     =			super().__call__(*UpperCAmelCase__    ,      **UpperCAmelCase__    )
        if (
            isinstance(args[0]    ,      UpperCAmelCase__    )
            and all(isinstance(UpperCAmelCase__    ,      UpperCAmelCase__    ) for el in args[0]    )
            and all(len(UpperCAmelCase__    ) == 1 for res in result    )
        ):
           return [res[0] for res in result]
        return result





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    ,      UpperCAmelCase__       :      Any    ,      UpperCAmelCase__       :      Optional[Any]=TruncationStrategy.DO_NOT_TRUNCATE    ,      **UpperCAmelCase__       :      int    )				->  int:
        lowerCAmelCase     =			self._parse_and_tokenize(UpperCAmelCase__    ,      truncation=UpperCAmelCase__    ,      **UpperCAmelCase__    )
        return inputs





     def 							__UpperCAmelCase      ( self       :      int    ,      UpperCAmelCase__       :      Union[str, Any]    ,      **UpperCAmelCase__       :      str    )				->  Tuple:
        if self.framework == "pt":
           lowerCAmelCase     ,  lowerCAmelCase     =			model_inputs['input_ids'].shape
        elif self.framework == "tf":
           lowerCAmelCase     ,  lowerCAmelCase     =			tf.shape(model_inputs['input_ids']    ).numpy()

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





     def 							__UpperCAmelCase      ( self       :      List[str]    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      List[Any]=ReturnType.TEXT    ,      UpperCAmelCase__       :      str=False    )				->  int:
        lowerCAmelCase     =			[]
        for output_ids in model_outputs["output_ids"][0]:
           if return_type == ReturnType.TENSORS:
              lowerCAmelCase     =			{F'''{self.return_name}_token_ids''': output_ids}
           elif return_type == ReturnType.TEXT:
              lowerCAmelCase     =			{
                  F'''{self.return_name}_text''': self.tokenizer.decode(
                      UpperCAmelCase__    ,      skip_special_tokens=UpperCAmelCase__    ,      clean_up_tokenization_spaces=UpperCAmelCase__    ,      )
              }
           records.append(UpperCAmelCase__    )
        return records




@add_end_docstrings(__lowercase		)
class 		UpperCAmelCase_      (  __lowercase		):
     lowerCamelCase				:	Union[str, Any]		=     '''summary'''





     def __call__( self       :      Any    ,      *UpperCAmelCase__       :      int    ,      **UpperCAmelCase__       :      str    )				->  Union[str, Any]:
        return super().__call__(*UpperCAmelCase__    ,      **UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Optional[int]    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    )				->  bool:
        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(__lowercase		)
class 		UpperCAmelCase_      (  __lowercase		):
     lowerCamelCase				:	Union[str, Any]		=     '''translation'''





     def 							__UpperCAmelCase      ( self       :      str    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    )				->  Union[str, Any]:
        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       :      Union[str, Any]    ,      *UpperCAmelCase__       :      Optional[int]    ,      UpperCAmelCase__       :      Optional[int]=TruncationStrategy.DO_NOT_TRUNCATE    ,      UpperCAmelCase__       :      str=None    ,      UpperCAmelCase__       :      Optional[int]=None    )				->  str:
        if getattr(self.tokenizer    ,      '_build_translation_inputs'    ,      UpperCAmelCase__    ):
           return self.tokenizer._build_translation_inputs(
               *UpperCAmelCase__    ,      return_tensors=self.framework    ,      truncation=UpperCAmelCase__    ,      src_lang=UpperCAmelCase__    ,      tgt_lang=UpperCAmelCase__    )
        else:
           return super()._parse_and_tokenize(*UpperCAmelCase__    ,      truncation=UpperCAmelCase__    )





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





     def __call__( self       :      Optional[int]    ,      *UpperCAmelCase__       :      int    ,      **UpperCAmelCase__       :      Any    )				->  List[Any]:
        return super().__call__(*UpperCAmelCase__    ,      **UpperCAmelCase__    )









'''simple docstring'''




import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu

@require_cpu
class 		UpperCAmelCase_      (  unittest.TestCase		):





     def 							__UpperCAmelCase      ( self       :      str    )				->  List[Any]:
        lowerCAmelCase     =			torch.nn.Linear(1_0    ,      1_0    )
        lowerCAmelCase     =			torch.optim.SGD(model.parameters()    ,      0.1    )
        lowerCAmelCase     =			Accelerator()
        lowerCAmelCase     =			accelerator.prepare(UpperCAmelCase__    )
        try:
           pickle.loads(pickle.dumps(UpperCAmelCase__    )    )
        except Exception as e:
           self.fail(F'''Accelerated optimizer pickling failed with {e}'''    )
        AcceleratorState._reset_state()





