


'''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__				     =		logging.get_logger(__name__)





class 						__SCREAMING_SNAKE_CASE					(      enum.Enum ):
     UpperCAmelCase 					=				0
     UpperCAmelCase 					=				1







@add_end_docstrings(lowerCamelCase__ )
class 						__SCREAMING_SNAKE_CASE					(      lowerCamelCase__ ):
     UpperCAmelCase 					=				'''generated'''






     def __init__(			self     ,							*__UpperCamelCase     ,							**__UpperCamelCase		)       ->    List[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  a_					(			self     ,							__UpperCamelCase=None     ,							__UpperCamelCase=None     ,							__UpperCamelCase=None     ,							__UpperCamelCase=None     ,							__UpperCamelCase=None     ,							__UpperCamelCase=None     ,							**__UpperCamelCase     ,							)       ->    Union[str, Any]:
          _a						=		{}
          if truncation is not None:
               _a						=		truncation

          _a						=		generate_kwargs

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

          if clean_up_tokenization_spaces is not None:
               _a						=		clean_up_tokenization_spaces

          if stop_sequence is not None:
               _a						=		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."		)
               _a						=		stop_sequence_ids[0]

          return preprocess_params, forward_params, postprocess_params






     def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    Any:
          return True






     def  a_					(			self     ,							*__UpperCamelCase     ,							__UpperCamelCase		)       ->    Tuple:
          _a						=		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"		)
               _a						=		([prefix + arg for arg in args[0]],)
               _a						=		True

          elif isinstance(args[0]     ,							lowercase_		):
               _a						=		(prefix + args[0],)
               _a						=		False
          else:
               raise ValueError(
                   f" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`"		)
          _a						=		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     ,							*__UpperCamelCase     ,							**__UpperCamelCase		)       ->    Dict:
          _a						=		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  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase=TruncationStrategy.DO_NOT_TRUNCATE     ,							**__UpperCamelCase		)       ->    Optional[int]:
          _a						=		self._parse_and_tokenize(lowercase_     ,							truncation=lowercase_     ,							**lowercase_		)
          return inputs






     def  a_					(			self     ,							__UpperCamelCase     ,							**__UpperCamelCase		)       ->    str:







          if self.framework == "pt":
               _a			,			_a						=		model_inputs["input_ids"].shape
          elif self.framework == "tf":
               _a			,			_a						=		tf.shape(model_inputs["input_ids"]		).numpy()

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






     def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase=ReturnType.TEXT     ,							__UpperCamelCase=False		)       ->    Tuple:
          _a						=		[]
          for output_ids in model_outputs["output_ids"][0]:
               if return_type == ReturnType.TENSORS:
                    _a						=		{f"{self.return_name}_token_ids": output_ids}
               elif return_type == ReturnType.TEXT:
                    _a						=		{
                        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(lowerCamelCase__ )
class 						__SCREAMING_SNAKE_CASE					(      lowerCamelCase__ ):
     UpperCAmelCase 					=				'''summary'''






     def __call__(			self     ,							*__UpperCamelCase     ,							**__UpperCamelCase		)       ->    Optional[int]:
          return super().__call__(*lowercase_     ,							**lowercase_		)






     def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    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(lowerCamelCase__ )
class 						__SCREAMING_SNAKE_CASE					(      lowerCamelCase__ ):
     UpperCAmelCase 					=				'''translation'''






     def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    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  a_					(			self     ,							*__UpperCamelCase     ,							__UpperCamelCase=TruncationStrategy.DO_NOT_TRUNCATE     ,							__UpperCamelCase=None     ,							__UpperCamelCase=None		)       ->    List[str]:







          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  a_					(			self     ,							__UpperCamelCase=None     ,							__UpperCamelCase=None     ,							**__UpperCamelCase		)       ->    List[Any]:
          _a			,			_a			,			_a						=		super()._sanitize_parameters(**lowercase_		)
          if src_lang is not None:
               _a						=		src_lang
          if tgt_lang is not None:
               _a						=		tgt_lang
          if src_lang is None and tgt_lang is None:
               # Backward compatibility, direct arguments use is preferred.
               _a						=		kwargs.get("task"     ,							self.task		)
               _a						=		task.split("_"		)
               if task and len(lowercase_		) == 4:
                    # translation, XX, to YY
                    _a						=		items[1]
                    _a						=		items[3]
          return preprocess_params, forward_params, postprocess_params






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









'''simple docstring'''

lowercase__				     =		65_521






def __UpperCamelCase   (			__lowerCamelCase		: str				)      ->     int:







     '''simple docstring'''






     _a						=		1
     _a						=		0
     for plain_chr in plain_text:
          _a						=		(a + ord(__lowerCamelCase				)) % MOD_ADLER
          _a						=		(b + a) % MOD_ADLER
     return (b << 16) | a

