
"""simple docstring"""



from numpy import exp, pi, sqrt


def  _UpperCamelCase	(						_A					,      _A = 0.0					,      _A = 1.0      )    ->  List[Any]:





    """simple docstring"""

    return 1 / sqrt(2 * pi * sigma**2      ) * exp(-((x - mu) ** 2) / (2 * sigma**2)      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

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

a					:	List[str]							=		logging.get_logger(__name__)




class 		a_						( enum.Enum	):
    a      :				Optional[Any]     =				0
    a      :				Dict     =				1







@add_end_docstrings(_UpperCAmelCase	)
class 		a_						( _UpperCAmelCase	):
    a      :				List[Any]     =				'generated'







    def __init__(			self			:       int     ,					*__UpperCamelCase			:       Optional[int]     ,					**__UpperCamelCase			:       str     )		->Any:






        '''simple docstring'''






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






        '''simple docstring'''






        _UpperCAmelCase          =   {}
        if truncation is not None:
            _UpperCAmelCase          =   truncation

        _UpperCAmelCase          =   generate_kwargs

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

        if clean_up_tokenization_spaces is not None:
            _UpperCAmelCase          =   clean_up_tokenization_spaces

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

        return preprocess_params, forward_params, postprocess_params







    def      _snake_case					(			self			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     )		->Any:






        '''simple docstring'''






        return True







    def      _snake_case					(			self			:       Optional[Any]     ,					*__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       Dict     )		->Dict:






        '''simple docstring'''






        _UpperCAmelCase          =   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"""     )
            _UpperCAmelCase          =   ([prefix + arg for arg in args[0]],)
            _UpperCAmelCase          =   True

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






        '''simple docstring'''






        _UpperCAmelCase          =   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      _snake_case					(			self			:       List[str]     ,					__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       str=TruncationStrategy.DO_NOT_TRUNCATE     ,					**__UpperCamelCase			:       Optional[int]     )		->Optional[int]:






        '''simple docstring'''






        _UpperCAmelCase          =   self._parse_and_tokenize(__UpperCamelCase     ,					truncation=__UpperCamelCase     ,					**__UpperCamelCase     )
        return inputs







    def      _snake_case					(			self			:       str     ,					__UpperCamelCase			:       Dict     ,					**__UpperCamelCase			:       Dict     )		->Tuple:






        '''simple docstring'''






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

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







    def      _snake_case					(			self			:       Tuple     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       Union[str, Any]=ReturnType.TEXT     ,					__UpperCamelCase			:       int=False     )		->Any:






        '''simple docstring'''






        _UpperCAmelCase          =   []
        for output_ids in model_outputs["output_ids"][0]:
            if return_type == ReturnType.TENSORS:
                _UpperCAmelCase          =   {f"""{self.return_name}_token_ids""": output_ids}
            elif return_type == ReturnType.TEXT:
                _UpperCAmelCase          =   {
                    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 		a_						( _UpperCAmelCase	):
    a      :				List[Any]     =				'summary'







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






        '''simple docstring'''






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







    def      _snake_case					(			self			:       str     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       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(_UpperCAmelCase	)
class 		a_						( _UpperCAmelCase	):
    a      :				Optional[int]     =				'translation'







    def      _snake_case					(			self			:       Union[str, Any]     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     )		->Any:






        '''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      _snake_case					(			self			:       Tuple     ,					*__UpperCamelCase			:       List[str]     ,					__UpperCamelCase			:       Tuple=TruncationStrategy.DO_NOT_TRUNCATE     ,					__UpperCamelCase			:       Tuple=None     ,					__UpperCamelCase			:       Union[str, Any]=None     )		->Tuple:






        '''simple docstring'''






        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      _snake_case					(			self			:       List[str]     ,					__UpperCamelCase			:       int=None     ,					__UpperCamelCase			:       int=None     ,					**__UpperCamelCase			:       Any     )		->int:






        '''simple docstring'''






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







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






        '''simple docstring'''






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