


import uuid
from typing import Any, Dict, List, Optional, Union

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

if is_torch_available():
 import torch


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

class   A__ :







    """simple docstring"""

    def __init__(	self      , __snake_case = None      , __snake_case = None      , __snake_case=None      , __snake_case=None   ):
         if not conversation_id:
              snake_case					=    uuid.uuida()
         if past_user_inputs is None:
              snake_case					=    []
         if generated_responses is None:
              snake_case					=    []

         snake_case					=    conversation_id
         snake_case					=    past_user_inputs
         snake_case					=    generated_responses
         snake_case					=    text
    def __eq__(	self      , __snake_case   ):
         if not isinstance(__snake_case      , __snake_case   ):
              return False
         if self.uuid == other.uuid:
              return True
         return (
             self.new_user_input == other.new_user_input
             and self.past_user_inputs == other.past_user_inputs
             and self.generated_responses == other.generated_responses
         )
    def 		a_      (	self      , __snake_case      , __snake_case = False   ):
         if self.new_user_input:
              if overwrite:
                   logger.warning(
                       F'''User input added while unprocessed input was existing: "{self.new_user_input}" was overwritten '''
                       F'''with: "{text}".'''   )
                   snake_case					=    text
              else:
                   logger.warning(
                       F'''User input added while unprocessed input was existing: "{self.new_user_input}" new input '''
                       F'''ignored: "{text}". Set `overwrite` to True to overwrite unprocessed user input'''   )
         else:
              snake_case					=    text
    def 		a_      (	self   ):
         if self.new_user_input:
              self.past_user_inputs.append(self.new_user_input   )
         snake_case					=    None
    def 		a_      (	self      , __snake_case   ):
         self.generated_responses.append(__snake_case   )
    def 		a_      (	self   ):
         for user_input, generated_response in zip(self.past_user_inputs      , self.generated_responses   ):
              yield True, user_input
              yield False, generated_response
         if self.new_user_input:
              yield True, self.new_user_input




    def __repr__(	self   ):
         snake_case					=    F'''Conversation id: {self.uuid} \n'''
         for is_user, text in self.iter_texts():
              snake_case					=    '''user''' if is_user else '''bot'''
              output += F'''{name} >> {text} \n'''
         return output






@add_end_docstrings(
    snake_case__	, r'\n        min_length_for_response (`int`, *optional*, defaults to 32):\n            The minimum length (in number of tokens) for a response.\n        minimum_tokens (`int`, *optional*, defaults to 10):\n            The minimum length of tokens to leave for a response.\n    '	, )
class   A__ (   snake_case__     ):







    """simple docstring"""

    def __init__(	self      , *__snake_case      , **__snake_case   ):
         super().__init__(*__snake_case      , **__snake_case   )
         if self.tokenizer.pad_token_id is None:
              snake_case					=    self.tokenizer.eos_token
    def 		a_      (	self      , __snake_case=None      , __snake_case=None      , __snake_case=None      , **__snake_case   ):
         snake_case					=    {}
         snake_case					=    {}
         snake_case					=    {}

         if min_length_for_response is not None:
              snake_case					=    min_length_for_response
         if minimum_tokens is not None:
              snake_case					=    minimum_tokens

         if "max_length" in generate_kwargs:
              snake_case					=    generate_kwargs['''max_length''']
              # self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
         if clean_up_tokenization_spaces is not None:
              snake_case					=    clean_up_tokenization_spaces

         if generate_kwargs:
              forward_params.update(__snake_case   )
         return preprocess_params, forward_params, postprocess_params
    def __call__(	self      , __snake_case      , __snake_case=0      , **__snake_case   ):
         snake_case					=    super().__call__(__snake_case      , num_workers=__snake_case      , **__snake_case   )
         if isinstance(__snake_case      , __snake_case   ) and len(__snake_case   ) == 1:
              return outputs[0]
         return outputs
    def 		a_      (	self      , __snake_case      , __snake_case=3_2   ):
         if not isinstance(__snake_case      , __snake_case   ):
              raise ValueError('''ConversationalPipeline, expects Conversation as inputs'''   )
         if conversation.new_user_input is None:
              raise ValueError(
                  F'''Conversation with UUID {type(conversation.uuid   )} does not contain new user input to process. '''
                  '''Add user inputs with the conversation\'s `add_user_input` method'''   )
         if hasattr(self.tokenizer      , '''_build_conversation_input_ids'''   ):
              snake_case					=    self.tokenizer._build_conversation_input_ids(__snake_case   )
         else:
              # If the tokenizer cannot handle conversations, we default to only the old version
              snake_case					=    self._legacy_parse_and_tokenize(__snake_case   )

         if self.framework == "pt":
              snake_case					=    torch.LongTensor([input_ids]   )
         elif self.framework == "tf":
              snake_case					=    tf.constant([input_ids]   )
         return {"input_ids": input_ids, "conversation": conversation}
    def 		a_      (	self      , __snake_case      , __snake_case=1_0      , **__snake_case   ):
         snake_case					=    generate_kwargs.get('''max_length'''      , self.model.config.max_length   )

         snake_case					=    model_inputs['''input_ids'''].shape[1]
         if max_length - minimum_tokens < n:
              logger.warning(F'''Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})'''   )
              snake_case					=    max_length - minimum_tokens
              snake_case					=    model_inputs['''input_ids'''][:, -trim:]
              if "attention_mask" in model_inputs:
                   snake_case					=    model_inputs['''attention_mask'''][:, -trim:]
         snake_case					=    model_inputs.pop('''conversation'''   )
         snake_case					=    max_length
         snake_case					=    self.model.generate(**__snake_case      , **__snake_case   )
         if self.model.config.is_encoder_decoder:
              snake_case					=    1
         else:
              snake_case					=    n
         return {"output_ids": output_ids[:, start_position:], "conversation": conversation}
    def 		a_      (	self      , __snake_case      , __snake_case=True   ):
         snake_case					=    model_outputs['''output_ids''']
         snake_case					=    self.tokenizer.decode(
             output_ids[0]      , skip_special_tokens=__snake_case      , clean_up_tokenization_spaces=__snake_case      , )
         snake_case					=    model_outputs['''conversation''']
         conversation.mark_processed()
         conversation.append_response(__snake_case   )
         return conversation




    def 		a_      (	self      , __snake_case   ):
         snake_case					=    self.tokenizer.eos_token_id
         snake_case					=    []
         for is_user, text in conversation.iter_texts():
              if eos_token_id is not None:
                   input_ids.extend(self.tokenizer.encode(__snake_case      , add_special_tokens=__snake_case   ) + [eos_token_id]   )
              else:
                   input_ids.extend(self.tokenizer.encode(__snake_case      , add_special_tokens=__snake_case   )   )

         if len(__snake_case   ) > self.tokenizer.model_max_length:
              snake_case					=    input_ids[-self.tokenizer.model_max_length :]
         return input_ids






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

_SCREAMING_SNAKE_CASE      :			Tuple      				=   logging.get_logger(__name__)

class   A__ (   enum.Enum     ):







    """simple docstring"""

    __magic_name__        =		0
    __magic_name__        =		1






@add_end_docstrings(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'generated'
    def __init__(	self      , *__snake_case      , **__snake_case   ):
         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 		a_      (	self      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , **__snake_case      , ):
         snake_case					=    {}
         if truncation is not None:
              snake_case					=    truncation

         snake_case					=    generate_kwargs

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

         if clean_up_tokenization_spaces is not None:
              snake_case					=    clean_up_tokenization_spaces

         if stop_sequence is not None:
              snake_case					=    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					=    stop_sequence_ids[0]

         return preprocess_params, forward_params, postprocess_params
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         return True
    def 		a_      (	self      , *__snake_case      , __snake_case   ):
         snake_case					=    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					=    ([prefix + arg for arg in args[0]],)
              snake_case					=    True

         elif isinstance(args[0]      , __snake_case   ):
              snake_case					=    (prefix + args[0],)
              snake_case					=    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					=    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      , *__snake_case      , **__snake_case   ):
         snake_case					=    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 		a_      (	self      , __snake_case      , __snake_case=TruncationStrategy.DO_NOT_TRUNCATE      , **__snake_case   ):
         snake_case					=    self._parse_and_tokenize(__snake_case      , truncation=__snake_case      , **__snake_case   )
         return inputs
    def 		a_      (	self      , __snake_case      , **__snake_case   ):
         if self.framework == "pt":
              snake_case			,  snake_case					=    model_inputs['''input_ids'''].shape
         elif self.framework == "tf":
              snake_case			,  snake_case					=    tf.shape(model_inputs['''input_ids''']   ).numpy()

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




    def 		a_      (	self      , __snake_case      , __snake_case=ReturnType.TEXT      , __snake_case=False   ):
         snake_case					=    []
         for output_ids in model_outputs["output_ids"][0]:
              if return_type == ReturnType.TENSORS:
                   snake_case					=    {F'''{self.return_name}_token_ids''': output_ids}
              elif return_type == ReturnType.TEXT:
                   snake_case					=    {
                       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(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'summary'
    def __call__(	self      , *__snake_case      , **__snake_case   ):
         return super().__call__(*__snake_case      , **__snake_case   )




    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         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(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

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




    def __call__(	self      , *__snake_case      , **__snake_case   ):
         return super().__call__(*__snake_case      , **__snake_case   )




