



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


_UpperCAmelCase     =	logging.get_logger(__name__)
class 					a	:



  def __init__(						self :					Any       ,		lowerCAmelCase :					str = None       ,		lowerCAmelCase :					uuid.UUID = None       ,		lowerCAmelCase :					List[str]=None       ,		lowerCAmelCase :					Any=None		)     ->					Optional[Any]:


     '''simple docstring'''




     if not conversation_id:
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=uuid.uuida()
     if past_user_inputs is None:
        SCREAMING_SNAKE_CASE_: Tuple     			=[]
     if generated_responses is None:
        SCREAMING_SNAKE_CASE_: Any     			=[]

     SCREAMING_SNAKE_CASE_: uuid.UUID     			=conversation_id
     SCREAMING_SNAKE_CASE_: List[str]     			=past_user_inputs
     SCREAMING_SNAKE_CASE_: List[str]     			=generated_responses
     SCREAMING_SNAKE_CASE_: Optional[str]     			=text



  def __eq__(						self :					Optional[int]       ,		lowerCAmelCase :					List[str]		)     ->					Union[str, Any]:


     '''simple docstring'''




     if not isinstance(lowerCAmelCase       ,		lowerCAmelCase		):
        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 	lowerCamelCase__       (						self :					Optional[int]       ,		lowerCAmelCase :					str       ,		lowerCAmelCase :					bool = False		)     ->					Union[str, Any]:


     '''simple docstring'''




     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}".'''		)
           SCREAMING_SNAKE_CASE_: Optional[int]     			=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:
        SCREAMING_SNAKE_CASE_: int     			=text



  def 	lowerCamelCase__       (						self :					Dict		)     ->					Any:


     '''simple docstring'''




     if self.new_user_input:
        self.past_user_inputs.append(self.new_user_input		)
     SCREAMING_SNAKE_CASE_: Optional[int]     			=None



  def 	lowerCamelCase__       (						self :					List[Any]       ,		lowerCAmelCase :					str		)     ->					Any:


     '''simple docstring'''




     self.generated_responses.append(lowerCAmelCase		)



  def 	lowerCamelCase__       (						self :					int		)     ->					Optional[int]:


     '''simple docstring'''




     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 :					Optional[Any]		)     ->					Optional[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Dict     			=f'''Conversation id: {self.uuid} \n'''
     for is_user, text in self.iter_texts():
        SCREAMING_SNAKE_CASE_: List[Any]     			="""user""" if is_user else """bot"""
        output += f'''{name} >> {text} \n'''
     return output







@add_end_docstrings(
    UpperCAmelCase__	,      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	(  UpperCAmelCase__       ):



  def __init__(						self :					Tuple       ,		*lowerCAmelCase :					str       ,		**lowerCAmelCase :					str		)     ->					Any:


     '''simple docstring'''




     super().__init__(*lowerCAmelCase       ,		**lowerCAmelCase		)
     if self.tokenizer.pad_token_id is None:
        SCREAMING_SNAKE_CASE_: Tuple     			=self.tokenizer.eos_token



  def 	lowerCamelCase__       (						self :					int       ,		lowerCAmelCase :					List[str]=None       ,		lowerCAmelCase :					List[Any]=None       ,		lowerCAmelCase :					Any=None       ,		**lowerCAmelCase :					Dict		)     ->					Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Tuple     			={}
     SCREAMING_SNAKE_CASE_: str     			={}
     SCREAMING_SNAKE_CASE_: str     			={}

     if min_length_for_response is not None:
        SCREAMING_SNAKE_CASE_: List[Any]     			=min_length_for_response
     if minimum_tokens is not None:
        SCREAMING_SNAKE_CASE_: str     			=minimum_tokens

     if "max_length" in generate_kwargs:
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=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:
        SCREAMING_SNAKE_CASE_: Dict     			=clean_up_tokenization_spaces

     if generate_kwargs:
        forward_params.update(lowerCAmelCase		)
     return preprocess_params, forward_params, postprocess_params



  def __call__(						self :					Optional[int]       ,		lowerCAmelCase :					Union[Conversation, List[Conversation]]       ,		lowerCAmelCase :					Any=0       ,		**lowerCAmelCase :					Optional[int]		)     ->					Optional[int]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=super().__call__(lowerCAmelCase       ,		num_workers=lowerCAmelCase       ,		**lowerCAmelCase		)
     if isinstance(lowerCAmelCase       ,		lowerCAmelCase		) and len(lowerCAmelCase		) == 1:
        return outputs[0]
     return outputs



  def 	lowerCamelCase__       (						self :					Union[str, Any]       ,		lowerCAmelCase :					Conversation       ,		lowerCAmelCase :					List[str]=32		)     ->					Dict[str, Any]:


     '''simple docstring'''




     if not isinstance(lowerCAmelCase       ,		lowerCAmelCase		):
        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"""		):
        SCREAMING_SNAKE_CASE_: List[Any]     			=self.tokenizer._build_conversation_input_ids(lowerCAmelCase		)
     else:
        # If the tokenizer cannot handle conversations, we default to only the old version
        SCREAMING_SNAKE_CASE_: List[Any]     			=self._legacy_parse_and_tokenize(lowerCAmelCase		)

     if self.framework == "pt":
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=torch.LongTensor([input_ids]		)
     elif self.framework == "tf":
        SCREAMING_SNAKE_CASE_: str     			=tf.constant([input_ids]		)
     return {"input_ids": input_ids, "conversation": conversation}



  def 	lowerCamelCase__       (						self :					Optional[int]       ,		lowerCAmelCase :					str       ,		lowerCAmelCase :					str=10       ,		**lowerCAmelCase :					int		)     ->					Union[str, Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Optional[int]     			=generate_kwargs.get("""max_length"""       ,		self.model.config.max_length		)

     SCREAMING_SNAKE_CASE_: str     			=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})'''		)
        SCREAMING_SNAKE_CASE_: Tuple     			=max_length - minimum_tokens
        SCREAMING_SNAKE_CASE_: int     			=model_inputs["""input_ids"""][:, -trim:]
        if "attention_mask" in model_inputs:
           SCREAMING_SNAKE_CASE_: Optional[Any]     			=model_inputs["""attention_mask"""][:, -trim:]
     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=model_inputs.pop("""conversation"""		)
     SCREAMING_SNAKE_CASE_: List[Any]     			=max_length
     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=self.model.generate(**lowerCAmelCase       ,		**lowerCAmelCase		)
     if self.model.config.is_encoder_decoder:
        SCREAMING_SNAKE_CASE_: List[str]     			=1
     else:
        SCREAMING_SNAKE_CASE_: Tuple     			=n
     return {"output_ids": output_ids[:, start_position:], "conversation": conversation}



  def 	lowerCamelCase__       (						self :					Optional[int]       ,		lowerCAmelCase :					List[str]       ,		lowerCAmelCase :					Union[str, Any]=True		)     ->					List[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: str     			=model_outputs["""output_ids"""]
     SCREAMING_SNAKE_CASE_: List[str]     			=self.tokenizer.decode(
         output_ids[0]       ,		skip_special_tokens=lowerCAmelCase       ,		clean_up_tokenization_spaces=lowerCAmelCase       ,		)
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=model_outputs["""conversation"""]
     conversation.mark_processed()
     conversation.append_response(lowerCAmelCase		)
     return conversation





  def 	lowerCamelCase__       (						self :					Union[str, Any]       ,		lowerCAmelCase :					Conversation		)     ->					Dict:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Optional[Any]     			=self.tokenizer.eos_token_id
     SCREAMING_SNAKE_CASE_: List[Any]     			=[]
     for is_user, text in conversation.iter_texts():
        if eos_token_id is not None:
           input_ids.extend(self.tokenizer.encode(lowerCAmelCase       ,		add_special_tokens=lowerCAmelCase		) + [eos_token_id]		)
        else:
           input_ids.extend(self.tokenizer.encode(lowerCAmelCase       ,		add_special_tokens=lowerCAmelCase		)		)

     if len(lowerCAmelCase		) > self.tokenizer.model_max_length:
        SCREAMING_SNAKE_CASE_: List[Any]     			=input_ids[-self.tokenizer.model_max_length :]
     return input_ids








"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_UpperCAmelCase     =			{
    """configuration_xlm""": ["""XLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLMConfig""", """XLMOnnxConfig"""],
    """tokenization_xlm""": ["""XLMTokenizer"""],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCAmelCase     =			[
       """XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """XLMForMultipleChoice""",
       """XLMForQuestionAnswering""",
       """XLMForQuestionAnsweringSimple""",
       """XLMForSequenceClassification""",
       """XLMForTokenClassification""",
       """XLMModel""",
       """XLMPreTrainedModel""",
       """XLMWithLMHeadModel""",
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCAmelCase     =			[
       """TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TFXLMForMultipleChoice""",
       """TFXLMForQuestionAnsweringSimple""",
       """TFXLMForSequenceClassification""",
       """TFXLMForTokenClassification""",
       """TFXLMMainLayer""",
       """TFXLMModel""",
       """TFXLMPreTrainedModel""",
       """TFXLMWithLMHeadModel""",
   ]


if TYPE_CHECKING:
   from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
   from .tokenization_xlm import XLMTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_xlm import (
          XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          XLMForMultipleChoice,
          XLMForQuestionAnswering,
          XLMForQuestionAnsweringSimple,
          XLMForSequenceClassification,
          XLMForTokenClassification,
          XLMModel,
          XLMPreTrainedModel,
          XLMWithLMHeadModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_xlm import (
          TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFXLMForMultipleChoice,
          TFXLMForQuestionAnsweringSimple,
          TFXLMForSequenceClassification,
          TFXLMForTokenClassification,
          TFXLMMainLayer,
          TFXLMModel,
          TFXLMPreTrainedModel,
          TFXLMWithLMHeadModel,
      )

else:
   import sys

   _UpperCAmelCase     =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



