
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     UpperCAmelCase						(		enum.Enum					):
   A__   :						Union[str, Any]			=	0
   A__   :						List[Any]			=	1






@add_end_docstrings(A_					)
class     UpperCAmelCase						(		A_					):
   A__   :						Union[str, Any]			=	"generated"



   def __init__(self						:   Union[str, Any]       ,		*snake_case__						:   Tuple       ,		**snake_case__						:   Optional[int]					)						->      List[Any]:


          '''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 							_SCREAMING_SNAKE_CASE  (self						:   Any       ,		snake_case__						:   Optional[int]=None       ,		snake_case__						:   List[str]=None       ,		snake_case__						:   List[str]=None       ,		snake_case__						:   Union[str, Any]=None       ,		snake_case__						:   str=None       ,		snake_case__						:   List[Any]=None       ,		**snake_case__						:   Tuple       ,		)						->      Any:


          '''simple docstring'''


          snake_case			:  Union[str, Any]     							= {}
          if truncation is not None:
                 snake_case			:  Dict     							= truncation

          snake_case			:  List[str]     							= generate_kwargs

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

          if clean_up_tokenization_spaces is not None:
                 snake_case			:  Tuple     							= clean_up_tokenization_spaces

          if stop_sequence is not None:
                 snake_case			:  Union[str, Any]     							= 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."					)
                 snake_case			:  List[str]     							= stop_sequence_ids[0]

          return preprocess_params, forward_params, postprocess_params



   def 							_SCREAMING_SNAKE_CASE  (self						:   Dict       ,		snake_case__						:   int       ,		snake_case__						:   int       ,		snake_case__						:   int					)						->      str:


          '''simple docstring'''


          return True



   def 							_SCREAMING_SNAKE_CASE  (self						:   Dict       ,		*snake_case__						:   Union[str, Any]       ,		snake_case__						:   List[str]					)						->      List[str]:


          '''simple docstring'''


          snake_case			:  List[str]     							= 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"					)
                 snake_case			:  Union[str, Any]     							= ([prefix + arg for arg in args[0]],)
                 snake_case			:  str     							= True

          elif isinstance(args[0]       ,		snake_case__					):
                 snake_case			:  Tuple     							= (prefix + args[0],)
                 snake_case			:  Optional[Any]     							= False
          else:
                 raise ValueError(
                     f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`"""					)
          snake_case			:  List[str]     							= 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						:   Union[str, Any]       ,		*snake_case__						:   Optional[Any]       ,		**snake_case__						:   int					)						->      int:


          '''simple docstring'''


          snake_case			:  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 							_SCREAMING_SNAKE_CASE  (self						:   List[Any]       ,		snake_case__						:   Dict       ,		snake_case__						:   Any=TruncationStrategy.DO_NOT_TRUNCATE       ,		**snake_case__						:   List[Any]					)						->      Any:


          '''simple docstring'''


          snake_case			:  str     							= self._parse_and_tokenize(snake_case__       ,		truncation=snake_case__       ,		**snake_case__					)
          return inputs



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[Any]       ,		snake_case__						:   Union[str, Any]       ,		**snake_case__						:   List[str]					)						->      int:


          '''simple docstring'''


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

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



   def 							_SCREAMING_SNAKE_CASE  (self						:   List[str]       ,		snake_case__						:   int       ,		snake_case__						:   str=ReturnType.TEXT       ,		snake_case__						:   Union[str, Any]=False					)						->      Dict:


          '''simple docstring'''


          snake_case			:  Optional[Any]     							= []
          for output_ids in model_outputs["output_ids"][0]:
                 if return_type == ReturnType.TENSORS:
                        snake_case			:  Dict     							= {f"""{self.return_name}_token_ids""": output_ids}
                 elif return_type == ReturnType.TEXT:
                        snake_case			:  Optional[Any]     							= {
                            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_					):
   A__   :						Union[str, Any]			=	"summary"



   def __call__(self						:   str       ,		*snake_case__						:   Any       ,		**snake_case__						:   Any					)						->      Optional[int]:


          '''simple docstring'''


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



   def 							_SCREAMING_SNAKE_CASE  (self						:   Any       ,		snake_case__						:   int       ,		snake_case__						:   int       ,		snake_case__						:   int					)						->      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     UpperCAmelCase						(		A_					):
   A__   :						int			=	"translation"



   def 							_SCREAMING_SNAKE_CASE  (self						:   Any       ,		snake_case__						:   int       ,		snake_case__						:   int       ,		snake_case__						:   int					)						->      str:


          '''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       ,		*snake_case__						:   List[str]       ,		snake_case__						:   Union[str, Any]=TruncationStrategy.DO_NOT_TRUNCATE       ,		snake_case__						:   str=None       ,		snake_case__						:   Dict=None					)						->      Optional[Any]:


          '''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 							_SCREAMING_SNAKE_CASE  (self						:   List[Any]       ,		snake_case__						:   Tuple=None       ,		snake_case__						:   str=None       ,		**snake_case__						:   Union[str, Any]					)						->      List[str]:


          '''simple docstring'''


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



   def __call__(self						:   Dict       ,		*snake_case__						:   List[str]       ,		**snake_case__						:   int					)						->      str:


          '''simple docstring'''


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







from ..utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
)


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from ..utils.dummy_pt_objects import *  # noqa F403
else:
   from .scheduling_consistency_models import CMStochasticIterativeScheduler
   from .scheduling_ddim import DDIMScheduler
   from .scheduling_ddim_inverse import DDIMInverseScheduler
   from .scheduling_ddim_parallel import DDIMParallelScheduler
   from .scheduling_ddpm import DDPMScheduler
   from .scheduling_ddpm_parallel import DDPMParallelScheduler
   from .scheduling_deis_multistep import DEISMultistepScheduler
   from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler
   from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler
   from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler
   from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler
   from .scheduling_euler_discrete import EulerDiscreteScheduler
   from .scheduling_heun_discrete import HeunDiscreteScheduler
   from .scheduling_ipndm import IPNDMScheduler
   from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler
   from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler
   from .scheduling_karras_ve import KarrasVeScheduler
   from .scheduling_pndm import PNDMScheduler
   from .scheduling_repaint import RePaintScheduler
   from .scheduling_sde_ve import ScoreSdeVeScheduler
   from .scheduling_sde_vp import ScoreSdeVpScheduler
   from .scheduling_unclip import UnCLIPScheduler
   from .scheduling_unipc_multistep import UniPCMultistepScheduler
   from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin
   from .scheduling_vq_diffusion import VQDiffusionScheduler

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from ..utils.dummy_flax_objects import *  # noqa F403
else:
   from .scheduling_ddim_flax import FlaxDDIMScheduler
   from .scheduling_ddpm_flax import FlaxDDPMScheduler
   from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler
   from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler
   from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler
   from .scheduling_pndm_flax import FlaxPNDMScheduler
   from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler
   from .scheduling_utils_flax import (
       FlaxKarrasDiffusionSchedulers,
       FlaxSchedulerMixin,
       FlaxSchedulerOutput,
       broadcast_to_shape_from_left,
   )


try:
   if not (is_torch_available() and is_scipy_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from ..utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
   from .scheduling_lms_discrete import LMSDiscreteScheduler

try:
   if not (is_torch_available() and is_torchsde_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from ..utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
   from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler





