





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


a        =						logging.get_logger(__name__)







class __a :





   def __init__(					self				:			int				,lowerCamelCase				:			str = None				,lowerCamelCase				:			uuid.UUID = None				,lowerCamelCase				:			Optional[int]=None				,lowerCamelCase				:			Union[str, Any]=None    ):

      '''simple docstring'''

      if not conversation_id:
         __SCREAMING_SNAKE_CASE      							=       uuid.uuida()
      if past_user_inputs is None:
         __SCREAMING_SNAKE_CASE      							=       []
      if generated_responses is None:
         __SCREAMING_SNAKE_CASE      							=       []

      __SCREAMING_SNAKE_CASE      							=       conversation_id
      __SCREAMING_SNAKE_CASE      							=       past_user_inputs
      __SCREAMING_SNAKE_CASE      							=       generated_responses
      __SCREAMING_SNAKE_CASE      							=       text





   def __eq__(					self				:			str				,lowerCamelCase				:			Tuple    ):

      '''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      UpperCAmelCase__     (					self				:			Tuple				,lowerCamelCase				:			str				,lowerCamelCase				:			bool = False    ):

      '''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      							=       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      							=       text





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      if self.new_user_input:
         self.past_user_inputs.append(self.new_user_input    )
      __SCREAMING_SNAKE_CASE      							=       None





   def      UpperCAmelCase__     (					self				:			Optional[int]				,lowerCamelCase				:			str    ):

      '''simple docstring'''

      self.generated_responses.append(lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			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				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       f"""Conversation id: {self.uuid} \n"""
      for is_user, text in self.iter_texts():
         __SCREAMING_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			):





   def __init__(					self				:			str				,*lowerCamelCase				:			Tuple				,**lowerCamelCase				:			str    ):

      '''simple docstring'''

      super().__init__(*lowerCamelCase				,**lowerCamelCase    )
      if self.tokenizer.pad_token_id is None:
         __SCREAMING_SNAKE_CASE      							=       self.tokenizer.eos_token





   def      UpperCAmelCase__     (					self				:			List[str]				,lowerCamelCase				:			Union[str, Any]=None				,lowerCamelCase				:			Tuple=None				,lowerCamelCase				:			Union[str, Any]=None				,**lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       {}
      __SCREAMING_SNAKE_CASE      							=       {}
      __SCREAMING_SNAKE_CASE      							=       {}

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

      if "max_length" in generate_kwargs:
         __SCREAMING_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:
         __SCREAMING_SNAKE_CASE      							=       clean_up_tokenization_spaces

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





   def __call__(					self				:			List[Any]				,lowerCamelCase				:			Union[Conversation, List[Conversation]]				,lowerCamelCase				:			Tuple=0				,**lowerCamelCase				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       super().__call__(lowerCamelCase				,num_workers=lowerCamelCase				,**lowerCamelCase    )
      if isinstance(lowerCamelCase				,lowerCamelCase    ) and len(lowerCamelCase    ) == 1:
         return outputs[0]
      return outputs





   def      UpperCAmelCase__     (					self				:			Union[str, Any]				,lowerCamelCase				:			Conversation				,lowerCamelCase				:			Optional[int]=32    ):

      '''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      							=       self.tokenizer._build_conversation_input_ids(lowerCamelCase    )
      else:
         # If the tokenizer cannot handle conversations, we default to only the old version
         __SCREAMING_SNAKE_CASE      							=       self._legacy_parse_and_tokenize(lowerCamelCase    )

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





   def      UpperCAmelCase__     (					self				:			int				,lowerCamelCase				:			List[str]				,lowerCamelCase				:			Tuple=10				,**lowerCamelCase				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       generate_kwargs.get("""max_length"""				,self.model.config.max_length    )

      __SCREAMING_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})"""    )
         __SCREAMING_SNAKE_CASE      							=       max_length - minimum_tokens
         __SCREAMING_SNAKE_CASE      							=       model_inputs["""input_ids"""][:, -trim:]
         if "attention_mask" in model_inputs:
            __SCREAMING_SNAKE_CASE      							=       model_inputs["""attention_mask"""][:, -trim:]
      __SCREAMING_SNAKE_CASE      							=       model_inputs.pop("""conversation"""    )
      __SCREAMING_SNAKE_CASE      							=       max_length
      __SCREAMING_SNAKE_CASE      							=       self.model.generate(**lowerCamelCase				,**lowerCamelCase    )
      if self.model.config.is_encoder_decoder:
         __SCREAMING_SNAKE_CASE      							=       1
      else:
         __SCREAMING_SNAKE_CASE      							=       n
      return {"output_ids": output_ids[:, start_position:], "conversation": conversation}





   def      UpperCAmelCase__     (					self				:			Optional[Any]				,lowerCamelCase				:			str				,lowerCamelCase				:			Union[str, Any]=True    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       model_outputs["""output_ids"""]
      __SCREAMING_SNAKE_CASE      							=       self.tokenizer.decode(
          output_ids[0]				,skip_special_tokens=lowerCamelCase				,clean_up_tokenization_spaces=lowerCamelCase				,)
      __SCREAMING_SNAKE_CASE      							=       model_outputs["""conversation"""]
      conversation.mark_processed()
      conversation.append_response(lowerCamelCase    )
      return conversation





   def      UpperCAmelCase__     (					self				:			Dict				,lowerCamelCase				:			Conversation    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.tokenizer.eos_token_id
      __SCREAMING_SNAKE_CASE      							=       []
      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      							=       input_ids[-self.tokenizer.model_max_length :]
      return input_ids












'''simple docstring'''

import inspect
import unittest

import numpy as np

from transformers import ViTConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
    import jax

    from transformers.models.vit.modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel







class __a (   unittest.TestCase			):





   def __init__(					self				:			Optional[int]				,lowerCamelCase				:			str				,lowerCamelCase				:			List[str]=13				,lowerCamelCase				:			Optional[Any]=30				,lowerCamelCase				:			Dict=2				,lowerCamelCase				:			List[Any]=3				,lowerCamelCase				:			List[str]=True				,lowerCamelCase				:			str=True				,lowerCamelCase				:			Optional[int]=32				,lowerCamelCase				:			Dict=5				,lowerCamelCase				:			Optional[int]=4				,lowerCamelCase				:			List[Any]=37				,lowerCamelCase				:			Union[str, Any]="gelu"				,lowerCamelCase				:			List[Any]=0.1				,lowerCamelCase				:			Any=0.1				,lowerCamelCase				:			str=10				,lowerCamelCase				:			Dict=0.02				,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       parent
      __SCREAMING_SNAKE_CASE      							=       batch_size
      __SCREAMING_SNAKE_CASE      							=       image_size
      __SCREAMING_SNAKE_CASE      							=       patch_size
      __SCREAMING_SNAKE_CASE      							=       num_channels
      __SCREAMING_SNAKE_CASE      							=       is_training
      __SCREAMING_SNAKE_CASE      							=       use_labels
      __SCREAMING_SNAKE_CASE      							=       hidden_size
      __SCREAMING_SNAKE_CASE      							=       num_hidden_layers
      __SCREAMING_SNAKE_CASE      							=       num_attention_heads
      __SCREAMING_SNAKE_CASE      							=       intermediate_size
      __SCREAMING_SNAKE_CASE      							=       hidden_act
      __SCREAMING_SNAKE_CASE      							=       hidden_dropout_prob
      __SCREAMING_SNAKE_CASE      							=       attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE      							=       type_sequence_label_size
      __SCREAMING_SNAKE_CASE      							=       initializer_range

      # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
      __SCREAMING_SNAKE_CASE      							=       (image_size // patch_size) ** 2
      __SCREAMING_SNAKE_CASE      							=       num_patches + 1





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

      __SCREAMING_SNAKE_CASE      							=       ViTConfig(
          image_size=self.image_size				,patch_size=self.patch_size				,num_channels=self.num_channels				,hidden_size=self.hidden_size				,num_hidden_layers=self.num_hidden_layers				,num_attention_heads=self.num_attention_heads				,intermediate_size=self.intermediate_size				,hidden_act=self.hidden_act				,hidden_dropout_prob=self.hidden_dropout_prob				,attention_probs_dropout_prob=self.attention_probs_dropout_prob				,is_decoder=lowerCamelCase				,initializer_range=self.initializer_range				,)

      return config, pixel_values





   def      UpperCAmelCase__     (					self				:			Tuple				,lowerCamelCase				:			int				,lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       FlaxViTModel(config=lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )
      # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
      __SCREAMING_SNAKE_CASE      							=       (self.image_size, self.image_size)
      __SCREAMING_SNAKE_CASE      							=       (self.patch_size, self.patch_size)
      __SCREAMING_SNAKE_CASE      							=       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
      self.parent.assertEqual(result.last_hidden_state.shape				,(self.batch_size, num_patches + 1, self.hidden_size)    )





   def      UpperCAmelCase__     (					self				:			Union[str, Any]				,lowerCamelCase				:			Optional[int]				,lowerCamelCase				:			Dict    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.type_sequence_label_size
      __SCREAMING_SNAKE_CASE      							=       FlaxViTForImageClassification(config=lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )
      self.parent.assertEqual(result.logits.shape				,(self.batch_size, self.type_sequence_label_size)    )

      # test greyscale images
      __SCREAMING_SNAKE_CASE      							=       1
      __SCREAMING_SNAKE_CASE      							=       FlaxViTForImageClassification(lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.prepare_config_and_inputs()
      (
          (
          __SCREAMING_SNAKE_CASE
      )							,     (
          __SCREAMING_SNAKE_CASE
      )							,     
      )      							=       config_and_inputs
      __SCREAMING_SNAKE_CASE      							=       {"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_flax
class __a (   _snake_case,   unittest.TestCase			):
   __UpperCamelCase   : Any	      =	(FlaxViTModel, FlaxViTForImageClassification) if is_flax_available() else ()





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       FlaxViTModelTester(self    )
      __SCREAMING_SNAKE_CASE      							=       ConfigTester(self				,config_class=lowerCamelCase				,has_text_modality=lowerCamelCase				,hidden_size=37    )





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      self.config_tester.run_common_tests()





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       inspect.signature(model.__call__    )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __SCREAMING_SNAKE_CASE      							=       [*signature.parameters.keys()]

         __SCREAMING_SNAKE_CASE      							=       ["""pixel_values"""]
         self.assertListEqual(arg_names[:1]				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         with self.subTest(model_class.__name__    ):
            __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase    )
            __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )

            @jax.jit
            def model_jitted(lowerCamelCase				:			int				,**lowerCamelCase				:			Union[str, Any]    ):
               return model(pixel_values=lowerCamelCase				,**lowerCamelCase    )

            with self.subTest("""JIT Enabled"""    ):
               __SCREAMING_SNAKE_CASE      							=       model_jitted(**lowerCamelCase    ).to_tuple()

            with self.subTest("""JIT Disabled"""    ):
               with jax.disable_jit():
                  __SCREAMING_SNAKE_CASE      							=       model_jitted(**lowerCamelCase    ).to_tuple()

            self.assertEqual(len(lowerCamelCase    )				,len(lowerCamelCase    )    )
            for jitted_output, output in zip(lowerCamelCase				,lowerCamelCase    ):
               self.assertEqual(jitted_output.shape				,output.shape    )





   @slow
   def      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      for model_class_name in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       model_class_name.from_pretrained("""google/vit-base-patch16-224"""    )
         __SCREAMING_SNAKE_CASE      							=       model(np.ones((1, 3, 224, 224)    )    )
         self.assertIsNotNone(lowerCamelCase    )





