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





class 					__magic_name__		(					enum.Enum):
   UpperCamelCase__       = 0
   UpperCamelCase__       = 1





@add_end_docstrings(_UpperCAmelCase)
class 					__magic_name__		(					_UpperCAmelCase):
   UpperCamelCase__       = '''generated'''







   def __init__(			self       :						str       ,    *lowercase_       :						Union[str, Any]       ,    **lowercase_       :						Optional[int]					):
          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 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[Any]       ,    lowercase_       :						List[Any]=None       ,    lowercase_       :						Tuple=None       ,    lowercase_       :						int=None       ,    lowercase_       :						Dict=None       ,    lowercase_       :						List[str]=None       ,    lowercase_       :						str=None       ,    **lowercase_       :						List[str]       ,    ):
          lowercase_      :    Optional[Any]       		= {}
          if truncation is not None:
                 lowercase_      :    Optional[Any]       		= truncation

          lowercase_      :    Dict       		= generate_kwargs

          lowercase_      :    Tuple       		= {}
          if return_tensors is not None and return_type is None:
                 lowercase_      :    str       		= ReturnType.TENSORS if return_tensors else ReturnType.TEXT
          if return_type is not None:
                 lowercase_      :    Dict       		= return_type

          if clean_up_tokenization_spaces is not None:
                 lowercase_      :    Union[str, Any]       		= clean_up_tokenization_spaces

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

          return preprocess_params, forward_params, postprocess_params







   def 			SCREAMING_SNAKE_CASE_  (			self       :						List[Any]       ,    lowercase_       :						int       ,    lowercase_       :						int       ,    lowercase_       :						int					):
          return True







   def 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[Any]       ,    *lowercase_       :						Dict       ,    lowercase_       :						Tuple					):
          lowercase_      :    int       		= 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"""					)
                 lowercase_      :    List[str]       		= ([prefix + arg for arg in args[0]],)
                 lowercase_      :    str       		= True

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







   def 			SCREAMING_SNAKE_CASE_  (			self       :						Union[str, Any]       ,    lowercase_       :						Dict       ,    **lowercase_       :						Any					):
          if self.framework == "pt":
                 lowercase_		,		lowercase_      :    int       		= model_inputs["""input_ids"""].shape
          elif self.framework == "tf":
                 lowercase_		,		lowercase_      :    Dict       		= tf.shape(model_inputs["""input_ids"""]					).numpy()

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







   def 			SCREAMING_SNAKE_CASE_  (			self       :						int       ,    lowercase_       :						Optional[Any]       ,    lowercase_       :						Optional[int]=ReturnType.TEXT       ,    lowercase_       :						Dict=False					):
          lowercase_      :    Optional[Any]       		= []
          for output_ids in model_outputs["output_ids"][0]:
                 if return_type == ReturnType.TENSORS:
                        lowercase_      :    str       		= {f'''{self.return_name}_token_ids''': output_ids}
                 elif return_type == ReturnType.TEXT:
                        lowercase_      :    Optional[int]       		= {
                            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(_UpperCAmelCase)
class 					__magic_name__		(					_UpperCAmelCase):
   UpperCamelCase__       = '''summary'''







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







   def 			SCREAMING_SNAKE_CASE_  (			self       :						str       ,    lowercase_       :						int       ,    lowercase_       :						int       ,    lowercase_       :						int					):
          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 					__magic_name__		(					_UpperCAmelCase):
   UpperCamelCase__       = '''translation'''







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







   def __call__(			self       :						List[str]       ,    *lowercase_       :						List[str]       ,    **lowercase_       :						Any					):
          return super().__call__(*UpperCAmelCase__       ,    **UpperCAmelCase__					)






'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


_lowercase		:				Optional[Any]	       =		{
    "configuration_swiftformer": [
        "SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "SwiftFormerConfig",
        "SwiftFormerOnnxConfig",
    ]
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowercase		:				Any	       =		[
						    "SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "SwiftFormerForImageClassification",
						    "SwiftFormerModel",
						    "SwiftFormerPreTrainedModel",
						]

if TYPE_CHECKING:
						from .configuration_swiftformer import (
						    SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    SwiftFormerConfig,
						    SwiftFormerOnnxConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_swiftformer import (
												    SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    SwiftFormerForImageClassification,
												    SwiftFormerModel,
												    SwiftFormerPreTrainedModel,
												)

else:
						import sys

						_lowercase		:				Optional[int]	       =		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





