'''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        a__ (  enum.Enum					):
     lowerCamelCase    :	Dict				=0
     lowerCamelCase    :	List[str]				=1




@add_end_docstrings(UpperCAmelCase__					)
class        a__ (  UpperCAmelCase__					):
     lowerCamelCase    :	Optional[Any]				="generated"






     def __init__(					self						:						List[Any]    ,							*a						:						Optional[Any]    ,							**a						:						Optional[int]       ):





         """simple docstring"""



         super().__init__(*a    ,							**a       )

         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						:						Tuple    ,							a						:						Dict=None    ,							a						:						List[Any]=None    ,							a						:						Tuple=None    ,							a						:						int=None    ,							a						:						Optional[int]=None    ,							a						:						Optional[Any]=None    ,							**a						:						Union[str, Any]    ,							):





         """simple docstring"""



         __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(a    ,							add_special_tokens=a       )
             if len(a       ) > 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   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]    ,							a						:						int    ,							a						:						int    ,							a						:						int       ):





         """simple docstring"""



         return True






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							*a						:						Any    ,							a						:						Tuple       ):





         """simple docstring"""



         __lowerCamelCase            =    self.model.config.prefix if self.model.config.prefix is not None else ''''''
         if isinstance(args[0]    ,							a       ):
             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]    ,							a       ):
             __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(*a    ,							padding=a    ,							truncation=a    ,							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						:						Tuple    ,							*a						:						Union[str, Any]    ,							**a						:						int       ):





         """simple docstring"""



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






     def   SCREAMING_SNAKE_CASE__  (					self						:						str    ,							a						:						Tuple    ,							a						:						Optional[int]=TruncationStrategy.DO_NOT_TRUNCATE    ,							**a						:						List[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    self._parse_and_tokenize(a    ,							truncation=a    ,							**a       )
         return inputs






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						Any    ,							**a						:						Tuple       ):





         """simple docstring"""



         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(a    ,							generate_kwargs['''min_length''']    ,							generate_kwargs['''max_length''']       )
         __lowerCamelCase            =    self.model.generate(**a    ,							**a       )
         __lowerCamelCase            =    output_ids.shape[0]
         if self.framework == "pt":
             __lowerCamelCase            =    output_ids.reshape(a    ,							out_b // in_b    ,							*output_ids.shape[1:]       )
         elif self.framework == "tf":
             __lowerCamelCase            =    tf.reshape(a    ,							(in_b, out_b // in_b, *output_ids.shape[1:])       )
         return {"output_ids": output_ids}






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]    ,							a						:						str    ,							a						:						Optional[Any]=ReturnType.TEXT    ,							a						:						int=False       ):





         """simple docstring"""



         __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(
                         a    ,							skip_special_tokens=a    ,							clean_up_tokenization_spaces=a    ,							)
                 }
             records.append(a       )
         return records




@add_end_docstrings(UpperCAmelCase__					)
class        a__ (  UpperCAmelCase__					):
     lowerCamelCase    :	List[Any]				="summary"






     def __call__(					self						:						str    ,							*a						:						Union[str, Any]    ,							**a						:						List[str]       ):





         """simple docstring"""



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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]    ,							a						:						int    ,							a						:						int    ,							a						:						int       ):





         """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(UpperCAmelCase__					)
class        a__ (  UpperCAmelCase__					):
     lowerCamelCase    :	Optional[Any]				="translation"






     def   SCREAMING_SNAKE_CASE__  (					self						:						str    ,							a						:						int    ,							a						:						int    ,							a						:						int       ):





         """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   SCREAMING_SNAKE_CASE__  (					self						:						int    ,							*a						:						Tuple    ,							a						:						Union[str, Any]=TruncationStrategy.DO_NOT_TRUNCATE    ,							a						:						Tuple=None    ,							a						:						Dict=None       ):





         """simple docstring"""



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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any    ,							a						:						int=None    ,							a						:						List[Any]=None    ,							**a						:						Optional[int]       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase      ,    __lowerCamelCase            =    super()._sanitize_parameters(**a       )
         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(a       ) == 4:
                 # translation, XX, to YY
                 __lowerCamelCase            =    items[1]
                 __lowerCamelCase            =    items[3]
         return preprocess_params, forward_params, postprocess_params






     def __call__(					self						:						Dict    ,							*a						:						List[str]    ,							**a						:						int       ):





         """simple docstring"""



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

'''simple docstring'''




def __lowerCAmelCase					(				UpperCamelCase__							)      ->       bool:
    if number < 0:
        raise ValueError('''number must not be negative'''							)
    return number & (number - 1) == 0


if __name__ == "__main__":
  import doctest

  doctest.testmod()
