

'''simple docstring'''

import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     FalconForCausalLM,
     FalconForQuestionAnswering,
     FalconForSequenceClassification,
     FalconForTokenClassification,
     FalconModel,
 )




class        A_ :






     '''simple docstring'''



     def __init__(		self :     Any     ,			lowercase_ :     Tuple     ,			lowercase_ :     str=3     ,			lowercase_ :     Optional[Any]=7     ,			lowercase_ :     Optional[Any]=True     ,			lowercase_ :     Union[str, Any]=True     ,			lowercase_ :     Tuple=False     ,			lowercase_ :     List[Any]=True     ,			lowercase_ :     Optional[Any]=99     ,			lowercase_ :     List[str]=32     ,			lowercase_ :     int=5     ,			lowercase_ :     str=4     ,			lowercase_ :     Any=37     ,			lowercase_ :     Union[str, Any]="gelu"     ,			lowercase_ :     List[str]=0.1     ,			lowercase_ :     int=0.1     ,			lowercase_ :     List[str]=512     ,			lowercase_ :     Optional[Any]=16     ,			lowercase_ :     List[str]=2     ,			lowercase_ :     Optional[int]=0.02     ,			lowercase_ :     Optional[Any]=3     ,			lowercase_ :     str=4     ,			lowercase_ :     Union[str, Any]=None     ,			)						->	Union[str, Any]:
      UpperCAmelCase       :	List[Any]											= parent
      UpperCAmelCase       :	Any											= batch_size
      UpperCAmelCase       :	Optional[Any]											= seq_length
      UpperCAmelCase       :	Dict											= is_training
      UpperCAmelCase       :	int											= use_input_mask
      UpperCAmelCase       :	List[str]											= use_token_type_ids
      UpperCAmelCase       :	Optional[int]											= use_labels
      UpperCAmelCase       :	Optional[int]											= vocab_size
      UpperCAmelCase       :	str											= hidden_size
      UpperCAmelCase       :	Dict											= num_hidden_layers
      UpperCAmelCase       :	str											= num_attention_heads
      UpperCAmelCase       :	Optional[Any]											= intermediate_size
      UpperCAmelCase       :	Dict											= hidden_act
      UpperCAmelCase       :	List[str]											= hidden_dropout_prob
      UpperCAmelCase       :	int											= attention_probs_dropout_prob
      UpperCAmelCase       :	int											= max_position_embeddings
      UpperCAmelCase       :	Union[str, Any]											= type_vocab_size
      UpperCAmelCase       :	List[str]											= type_sequence_label_size
      UpperCAmelCase       :	int											= initializer_range
      UpperCAmelCase       :	Dict											= num_labels
      UpperCAmelCase       :	Optional[int]											= num_choices
      UpperCAmelCase       :	Tuple											= scope


     def    UpperCAmelCase_       (		self :     List[str]       )						->	Any:
      UpperCAmelCase       :	Any											= ids_tensor([self.batch_size, self.seq_length]     ,			self.vocab_size       )

      UpperCAmelCase       :	Tuple											= None
      if self.use_input_mask:
       UpperCAmelCase       :	str											= random_attention_mask([self.batch_size, self.seq_length]       )

      UpperCAmelCase       :	Optional[int]											= None

      UpperCAmelCase       :	Optional[Any]											= None
      UpperCAmelCase       :	Optional[int]											= None
      UpperCAmelCase       :	str											= None
      if self.use_labels:
       UpperCAmelCase       :	Union[str, Any]											= ids_tensor([self.batch_size]     ,			self.type_sequence_label_size       )
       UpperCAmelCase       :	Dict											= ids_tensor([self.batch_size, self.seq_length]     ,			self.num_labels       )
       UpperCAmelCase       :	str											= ids_tensor([self.batch_size]     ,			self.num_choices       )

      UpperCAmelCase       :	Any											= self.get_config()

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


     def    UpperCAmelCase_       (		self :     Optional[int]       )						->	str:
      return FalconConfig(
          vocab_size=self.vocab_size     ,			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     ,			max_position_embeddings=self.max_position_embeddings     ,			type_vocab_size=self.type_vocab_size     ,			is_decoder=_lowerCAmelCase     ,			initializer_range=self.initializer_range     ,			pad_token_id=1     ,			new_decoder_architecture=_lowerCAmelCase     ,			)


     def    UpperCAmelCase_       (		self :     str     ,			lowercase_ :     Optional[int]     ,			lowercase_ :     Optional[int]     ,			lowercase_ :     str     ,			lowercase_ :     List[str]     ,			lowercase_ :     Optional[Any]     ,			lowercase_ :     Union[str, Any]     ,			lowercase_ :     str       )						->	Tuple:
      UpperCAmelCase       :	int											= FalconModel(config=_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()
      UpperCAmelCase       :	Optional[int]											= model(_lowerCAmelCase     ,			attention_mask=_lowerCAmelCase       )
      UpperCAmelCase       :	Tuple											= model(_lowerCAmelCase       )
      self.parent.assertEqual(result.last_hidden_state.shape     ,			(self.batch_size, self.seq_length, self.hidden_size)       )


     def    UpperCAmelCase_       (		self :     Optional[Any]     ,			lowercase_ :     List[str]     ,			lowercase_ :     Optional[int]     ,			lowercase_ :     Union[str, Any]     ,			lowercase_ :     str     ,			lowercase_ :     int     ,			lowercase_ :     str     ,			lowercase_ :     List[str]     ,			lowercase_ :     Union[str, Any]     ,			lowercase_ :     Tuple     ,			)						->	Optional[int]:
      UpperCAmelCase       :	Any											= True
      UpperCAmelCase       :	Any											= FalconModel(_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()
      UpperCAmelCase       :	List[str]											= model(
          _lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			encoder_hidden_states=_lowerCAmelCase     ,			encoder_attention_mask=_lowerCAmelCase     ,			)
      UpperCAmelCase       :	Tuple											= model(
          _lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			encoder_hidden_states=_lowerCAmelCase     ,			)
      UpperCAmelCase       :	Union[str, Any]											= model(_lowerCAmelCase     ,			attention_mask=_lowerCAmelCase       )
      self.parent.assertEqual(result.last_hidden_state.shape     ,			(self.batch_size, self.seq_length, self.hidden_size)       )


     def    UpperCAmelCase_       (		self :     int     ,			lowercase_ :     Optional[Any]     ,			lowercase_ :     Tuple     ,			lowercase_ :     List[Any]     ,			lowercase_ :     Union[str, Any]     ,			lowercase_ :     Any     ,			lowercase_ :     int     ,			lowercase_ :     Dict     ,			lowercase_ :     int     ,			lowercase_ :     List[str]     ,			)						->	Any:
      UpperCAmelCase       :	Tuple											= FalconForCausalLM(config=_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()
      UpperCAmelCase       :	Optional[Any]											= model(_lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			labels=_lowerCAmelCase       )
      self.parent.assertEqual(result.logits.shape     ,			(self.batch_size, self.seq_length, self.vocab_size)       )


     def    UpperCAmelCase_       (		self :     List[str]     ,			lowercase_ :     Union[str, Any]     ,			lowercase_ :     Optional[int]     ,			lowercase_ :     List[str]     ,			lowercase_ :     Optional[int]     ,			lowercase_ :     Tuple     ,			lowercase_ :     Any     ,			lowercase_ :     Any     ,			lowercase_ :     Optional[int]     ,			lowercase_ :     Union[str, Any]     ,			)						->	str:
      UpperCAmelCase       :	Dict											= True
      UpperCAmelCase       :	int											= True
      UpperCAmelCase       :	Dict											= FalconForCausalLM(config=_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()

      # first forward pass
      UpperCAmelCase       :	Any											= model(
          _lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			encoder_hidden_states=_lowerCAmelCase     ,			encoder_attention_mask=_lowerCAmelCase     ,			use_cache=_lowerCAmelCase     ,			)
      UpperCAmelCase       :	Any											= outputs.past_key_values

      # create hypothetical multiple next token and extent to next_input_ids
      UpperCAmelCase       :	int											= ids_tensor((self.batch_size, 3)     ,			config.vocab_size       )
      UpperCAmelCase       :	List[Any]											= ids_tensor((self.batch_size, 3)     ,			vocab_size=2       )

      # append to next input_ids and
      UpperCAmelCase       :	str											= torch.cat([input_ids, next_tokens]     ,			dim=-1       )
      UpperCAmelCase       :	int											= torch.cat([input_mask, next_mask]     ,			dim=-1       )

      UpperCAmelCase       :	Optional[int]											= model(
          _lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			encoder_hidden_states=_lowerCAmelCase     ,			encoder_attention_mask=_lowerCAmelCase     ,			output_hidden_states=_lowerCAmelCase     ,			)["hidden_states"][0]
      UpperCAmelCase       :	Any											= model(
          _lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			encoder_hidden_states=_lowerCAmelCase     ,			encoder_attention_mask=_lowerCAmelCase     ,			past_key_values=_lowerCAmelCase     ,			output_hidden_states=_lowerCAmelCase     ,			)["hidden_states"][0]

      # select random slice
      UpperCAmelCase       :	Union[str, Any]											= ids_tensor((1,)     ,			output_from_past.shape[-1]       ).item()
      UpperCAmelCase       :	Union[str, Any]											= output_from_no_past[:, -3:, random_slice_idx].detach()
      UpperCAmelCase       :	Union[str, Any]											= output_from_past[:, :, random_slice_idx].detach()

      self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]       )

      # test that outputs are equal for slice
      self.parent.assertTrue(torch.allclose(_lowerCAmelCase     ,			_lowerCAmelCase     ,			atol=1E-3       )       )




     def    UpperCAmelCase_       (		self :     Dict       )						->	Any:
      UpperCAmelCase       :	int											= self.prepare_config_and_inputs()
      (
          UpperCAmelCase			
      )       :	int											= config_and_inputs
      UpperCAmelCase       :	str											= {"input_ids": input_ids, "attention_mask": input_mask}
      return config, inputs_dict




@require_torch
class        A_ (				_snake_case       ,   _snake_case       ,   _snake_case       ,   unittest.TestCase							):






     '''simple docstring'''



     UpperCAmelCase_						:	str  		=  (
         (
             FalconModel,
             FalconForCausalLM,
             FalconForSequenceClassification,
             FalconForTokenClassification,
             FalconForQuestionAnswering,
         )
         if is_torch_available()
         else ()
     )
     UpperCAmelCase_						:	List[Any]  		=  (FalconForCausalLM,) if is_torch_available() else ()
     UpperCAmelCase_						:	Union[str, Any]  		=  (
         {
             """feature-extraction""": FalconModel,
             """text-classification""": FalconForSequenceClassification,
             """text-generation""": FalconForCausalLM,
             """question-answering""": FalconForQuestionAnswering,
             """token-classification""": FalconForTokenClassification,
             """zero-shot""": FalconForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     UpperCAmelCase_						:	Any  		=  False
     UpperCAmelCase_						:	Optional[int]  		=  False


     def    UpperCAmelCase_       (		self :     int       )						->	Tuple:
      UpperCAmelCase       :	List[Any]											= FalconModelTester(self       )
      UpperCAmelCase       :	int											= ConfigTester(self     ,			config_class=_lowerCAmelCase     ,			hidden_size=37       )


     def    UpperCAmelCase_       (		self :     List[Any]       )						->	str:
      self.config_tester.run_common_tests()


     def    UpperCAmelCase_       (		self :     List[str]       )						->	List[str]:
      UpperCAmelCase       :	Union[str, Any]											= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCAmelCase       )


     def    UpperCAmelCase_       (		self :     Any       )						->	Union[str, Any]:
      UpperCAmelCase       :	int											= self.model_tester.prepare_config_and_inputs()
      for alibi in [True, False]:
       UpperCAmelCase       :	List[str]											= alibi
       self.model_tester.create_and_check_model(_lowerCAmelCase     ,			*_lowerCAmelCase       )


     def    UpperCAmelCase_       (		self :     Optional[int]       )						->	int:
      UpperCAmelCase       :	Union[str, Any]											= self.model_tester.prepare_config_and_inputs_for_common()
      UpperCAmelCase       :	Optional[Any]											= 3
      UpperCAmelCase       :	Any											= input_dict["input_ids"]
      UpperCAmelCase       :	str											= input_ids.ne(1       ).to(_lowerCAmelCase       )
      UpperCAmelCase       :	Optional[int]											= ids_tensor([self.model_tester.batch_size]     ,			self.model_tester.type_sequence_label_size       )
      UpperCAmelCase       :	Optional[int]											= FalconForSequenceClassification(_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()
      UpperCAmelCase       :	int											= model(_lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			labels=_lowerCAmelCase       )
      self.assertEqual(result.logits.shape     ,			(self.model_tester.batch_size, self.model_tester.num_labels)       )


     def    UpperCAmelCase_       (		self :     str       )						->	Optional[Any]:
      UpperCAmelCase       :	int											= self.model_tester.prepare_config_and_inputs_for_common()
      UpperCAmelCase       :	Union[str, Any]											= 3
      UpperCAmelCase       :	str											= "single_label_classification"
      UpperCAmelCase       :	Dict											= input_dict["input_ids"]
      UpperCAmelCase       :	Optional[Any]											= input_ids.ne(1       ).to(_lowerCAmelCase       )
      UpperCAmelCase       :	str											= ids_tensor([self.model_tester.batch_size]     ,			self.model_tester.type_sequence_label_size       )
      UpperCAmelCase       :	Optional[int]											= FalconForSequenceClassification(_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()
      UpperCAmelCase       :	List[str]											= model(_lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			labels=_lowerCAmelCase       )
      self.assertEqual(result.logits.shape     ,			(self.model_tester.batch_size, self.model_tester.num_labels)       )


     def    UpperCAmelCase_       (		self :     Dict       )						->	str:
      UpperCAmelCase       :	Tuple											= self.model_tester.prepare_config_and_inputs_for_common()
      UpperCAmelCase       :	Optional[Any]											= input_dict["input_ids"]
      UpperCAmelCase       :	Any											= FalconForCausalLM(_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()
      UpperCAmelCase       :	Tuple											= model(_lowerCAmelCase     ,			use_cache=_lowerCAmelCase       )
      UpperCAmelCase       :	str											= input_ids.shape[0]
      UpperCAmelCase       :	List[str]											= model._convert_to_rw_cache(result.past_key_values       )
      UpperCAmelCase       :	str											= model._convert_cache_to_standard_format(_lowerCAmelCase     ,			_lowerCAmelCase       )
      for layer in range(len(_lowerCAmelCase       )       ):
       for tensor_idx in range(2       ):
        self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3       )
        self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4       )
        self.assertTrue(
            torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]       )       )


     def    UpperCAmelCase_       (		self :     List[Any]       )						->	Union[str, Any]:
      UpperCAmelCase       :	Optional[int]											= self.model_tester.prepare_config_and_inputs_for_common()
      UpperCAmelCase       :	List[Any]											= 3
      UpperCAmelCase       :	List[str]											= "multi_label_classification"
      UpperCAmelCase       :	int											= input_dict["input_ids"]
      UpperCAmelCase       :	Optional[int]											= input_ids.ne(1       ).to(_lowerCAmelCase       )
      UpperCAmelCase       :	Tuple											= ids_tensor(
          [self.model_tester.batch_size, config.num_labels]     ,			self.model_tester.type_sequence_label_size       ).to(torch.float       )
      UpperCAmelCase       :	Optional[Any]											= FalconForSequenceClassification(_lowerCAmelCase       )
      model.to(_lowerCAmelCase       )
      model.eval()
      UpperCAmelCase       :	Tuple											= model(_lowerCAmelCase     ,			attention_mask=_lowerCAmelCase     ,			labels=_lowerCAmelCase       )
      self.assertEqual(result.logits.shape     ,			(self.model_tester.batch_size, self.model_tester.num_labels)       )




     def    UpperCAmelCase_       (		self :     Dict       )						->	Optional[int]:
      # Falcon can have different numbers of KV-heads than the number of query heads, so we need
      # to override this test to use the right head counts.
      for model_class in self.all_generative_model_classes:
       UpperCAmelCase       :	List[str]											= self.model_tester.prepare_config_and_inputs_for_common()

       # If it doesn't support cache, pass the test
       if not hasattr(_lowerCAmelCase     ,			'use_cache'       ):
        return

       UpperCAmelCase       :	List[str]											= model_class(_lowerCAmelCase       ).to(_lowerCAmelCase       )
       if "use_cache" not in inputs:
        UpperCAmelCase       :	List[str]											= True
       UpperCAmelCase       :	str											= model(**_lowerCAmelCase       )

       # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
       if "past_key_values" not in outputs:
        return

       UpperCAmelCase       :	Tuple											= (
           getattr(_lowerCAmelCase     ,			'decoder_layers'     ,			_lowerCAmelCase       )
           or getattr(_lowerCAmelCase     ,			'num_decoder_layers'     ,			_lowerCAmelCase       )
           or config.num_hidden_layers
       )
       UpperCAmelCase       :	Tuple											= getattr(_lowerCAmelCase     ,			'num_kv_heads'     ,			config.num_attention_heads       )
       UpperCAmelCase       :	str											= getattr(_lowerCAmelCase     ,			'd_model'     ,			config.hidden_size       )
       UpperCAmelCase       :	Dict											= embed_dim // num_attention_heads

       UpperCAmelCase       :	List[str]											= outputs["past_key_values"]
       self.assertEqual(len(_lowerCAmelCase       )     ,			_lowerCAmelCase       )

       UpperCAmelCase       :	str											= inputs["input_ids"].shape
       for i in range(_lowerCAmelCase       ):
        if config.new_decoder_architecture:
         UpperCAmelCase       :	List[str]											= config.num_attention_heads
        elif config.multi_query:
         UpperCAmelCase       :	Dict											= 1
        self.assertEqual(len(past_kv[0]       )     ,			2       )  # K V for the decoder = 2
        self.assertEqual(
            past_kv[i][0].shape     ,			(batch_size, num_attention_heads, seq_length, per_head_embed_dim)       )
        self.assertEqual(
            past_kv[i][1].shape     ,			(batch_size, num_attention_heads, seq_length, per_head_embed_dim)       )




@require_torch
class        A_ (				unittest.TestCase							):






     '''simple docstring'''



     @slow
     def    UpperCAmelCase_       (		self :     str       )						->	int:
      UpperCAmelCase       :	List[str]											= AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'       )
      UpperCAmelCase       :	List[str]											= FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'       )
      model.eval()
      model.to(_lowerCAmelCase       )
      UpperCAmelCase       :	str											= tokenizer('My favorite food is'     ,			return_tensors='pt'       ).to(_lowerCAmelCase       )

      UpperCAmelCase       :	Dict											= (
          "My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday."
      )

      UpperCAmelCase       :	Any											= model.generate(**_lowerCAmelCase     ,			do_sample=_lowerCAmelCase     ,			max_new_tokens=19       )
      UpperCAmelCase       :	Any											= tokenizer.batch_decode(_lowerCAmelCase       )[0]

      self.assertEqual(_lowerCAmelCase     ,			_lowerCAmelCase       )


     @slow
     def    UpperCAmelCase_       (		self :     Optional[int]       )						->	Optional[Any]:
      # The big models are way too big for the CI, so we use tiny random models that resemble their
      # architectures but with much smaller and fewer layers
      for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
       UpperCAmelCase       :	Tuple											= AutoTokenizer.from_pretrained(_lowerCAmelCase       )
       UpperCAmelCase       :	List[str]											= FalconForCausalLM.from_pretrained(_lowerCAmelCase       )
       model.eval()
       model.to(_lowerCAmelCase       )
       UpperCAmelCase       :	Tuple											= tokenizer('My favorite food is'     ,			return_tensors='pt'       ).to(_lowerCAmelCase       )

       # We just test that these run without errors - the models are randomly initialized
       # and so the actual text outputs will be garbage
       model.generate(**_lowerCAmelCase     ,			do_sample=_lowerCAmelCase     ,			max_new_tokens=4       )
       model.generate(**_lowerCAmelCase     ,			do_sample=_lowerCAmelCase     ,			max_new_tokens=4       )
       model.generate(**_lowerCAmelCase     ,			num_beams=2     ,			max_new_tokens=4       )




     @slow
     def    UpperCAmelCase_       (		self :     Union[str, Any]       )						->	int:
      # The big models are way too big for the CI, so we use tiny random models that resemble their
      # architectures but with much smaller and fewer layers
      with torch.no_grad():
       for repo in [
           "Rocketknight1/falcon-rw-1b",
           "Rocketknight1/tiny-random-falcon-7b",
           "Rocketknight1/tiny-random-falcon-40b",
       ]:
        UpperCAmelCase       :	List[str]											= AutoTokenizer.from_pretrained(_lowerCAmelCase       )
        UpperCAmelCase       :	int											= FalconForCausalLM.from_pretrained(_lowerCAmelCase       )
        model.eval()
        model.to(device=_lowerCAmelCase       )
        UpperCAmelCase       :	Any											= tokenizer('My favorite food is'     ,			return_tensors='pt'       ).to(_lowerCAmelCase       )

        # Test results are the same with and without cache
        UpperCAmelCase       :	Optional[Any]											= model.generate(**_lowerCAmelCase     ,			do_sample=_lowerCAmelCase     ,			max_new_tokens=20     ,			use_cache=_lowerCAmelCase       )
        UpperCAmelCase       :	Union[str, Any]											= model.generate(**_lowerCAmelCase     ,			do_sample=_lowerCAmelCase     ,			max_new_tokens=20     ,			use_cache=_lowerCAmelCase       )
        self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0       )










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_UpperCAmelCase		:  List[str]	=   {
    "configuration_blenderbot": [
        "BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "BlenderbotConfig",
        "BlenderbotOnnxConfig",
    ],
    "tokenization_blenderbot": ["BlenderbotTokenizer"],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCAmelCase		:  Optional[int]	=   ["BlenderbotTokenizerFast"]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCAmelCase		:  int	=   [
         "BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST",
         "BlenderbotForCausalLM",
         "BlenderbotForConditionalGeneration",
         "BlenderbotModel",
         "BlenderbotPreTrainedModel",
     ]


try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCAmelCase		:  Any	=   [
         "TFBlenderbotForConditionalGeneration",
         "TFBlenderbotModel",
         "TFBlenderbotPreTrainedModel",
     ]


try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCAmelCase		:  Optional[int]	=   [
         "FlaxBlenderbotForConditionalGeneration",
         "FlaxBlenderbotModel",
         "FlaxBlenderbotPreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_blenderbot import (
         BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
         BlenderbotConfig,
         BlenderbotOnnxConfig,
     )
     from .tokenization_blenderbot import BlenderbotTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_blenderbot_fast import BlenderbotTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_blenderbot import (
              BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
              BlenderbotForCausalLM,
              BlenderbotForConditionalGeneration,
              BlenderbotModel,
              BlenderbotPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_blenderbot import (
              TFBlenderbotForConditionalGeneration,
              TFBlenderbotModel,
              TFBlenderbotPreTrainedModel,
          )

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_blenderbot import (
              FlaxBlenderbotForConditionalGeneration,
              FlaxBlenderbotModel,
              FlaxBlenderbotPreTrainedModel,
          )

else:
     import sys

     _UpperCAmelCase		:  Union[str, Any]	=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



