






import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import (
			    MODEL_MAPPING,
			    SegformerForImageClassification,
			    SegformerForSemanticSegmentation,
			    SegformerModel,
			)
			from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import SegformerImageProcessor
class  lowerCAmelCase_       (				snake_case__					):




							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						self.config_class(**self.inputs_dict	)
											self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_ ,							'''hidden_sizes'''	)	)
											self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_ ,							'''num_attention_heads'''	)	)
											self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_ ,							'''num_encoder_blocks'''	)	)



class  lowerCAmelCase_       :




							def __init__(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   List[Any]=13 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=64 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=3 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=4 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=[2, 2, 2, 2] ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=[8, 4, 2, 1] ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=[16, 32, 64, 128] ,							SCREAMING_SNAKE_CASE_     :   Tuple=[1, 4, 8, 16] ,							SCREAMING_SNAKE_CASE_     :   int=[1, 2, 4, 8] ,							SCREAMING_SNAKE_CASE_     :   str=True ,							SCREAMING_SNAKE_CASE_     :   Any=True ,							SCREAMING_SNAKE_CASE_     :   Any="gelu" ,							SCREAMING_SNAKE_CASE_     :   str=0.1 ,							SCREAMING_SNAKE_CASE_     :   str=0.1 ,							SCREAMING_SNAKE_CASE_     :   int=0.02 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=3 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=None ,							):
											lowerCAmelCase__      			=						parent
											lowerCAmelCase__      			=						batch_size
											lowerCAmelCase__      			=						image_size
											lowerCAmelCase__      			=						num_channels
											lowerCAmelCase__      			=						num_encoder_blocks
											lowerCAmelCase__      			=						sr_ratios
											lowerCAmelCase__      			=						depths
											lowerCAmelCase__      			=						hidden_sizes
											lowerCAmelCase__      			=						downsampling_rates
											lowerCAmelCase__      			=						num_attention_heads
											lowerCAmelCase__      			=						is_training
											lowerCAmelCase__      			=						use_labels
											lowerCAmelCase__      			=						hidden_act
											lowerCAmelCase__      			=						hidden_dropout_prob
											lowerCAmelCase__      			=						attention_probs_dropout_prob
											lowerCAmelCase__      			=						initializer_range
											lowerCAmelCase__      			=						num_labels
											lowerCAmelCase__      			=						scope




							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

											lowerCAmelCase__      			=						None
											if self.use_labels:
															lowerCAmelCase__      			=						ids_tensor([self.batch_size, self.image_size, self.image_size] ,							self.num_labels	)

											lowerCAmelCase__      			=						self.get_config()
											return config, pixel_values, labels




							def 						__snake_case					(   self     :   str	):
											return SegformerConfig(
											    image_size=self.image_size ,							num_channels=self.num_channels ,							num_encoder_blocks=self.num_encoder_blocks ,							depths=self.depths ,							hidden_sizes=self.hidden_sizes ,							num_attention_heads=self.num_attention_heads ,							hidden_act=self.hidden_act ,							hidden_dropout_prob=self.hidden_dropout_prob ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob ,							initializer_range=self.initializer_range ,							)




							def 						__snake_case					(   self     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Tuple	):
											lowerCAmelCase__      			=						SegformerModel(config=SCREAMING_SNAKE_CASE_	)
											model.to(SCREAMING_SNAKE_CASE_	)
											model.eval()
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						lowerCAmelCase__      			=						self.image_size // (self.downsampling_rates[-1] * 2)
											self.parent.assertEqual(
											    result.last_hidden_state.shape ,							(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)	)




							def 						__snake_case					(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Tuple	):
											lowerCAmelCase__      			=						self.num_labels
											lowerCAmelCase__      			=						SegformerForSemanticSegmentation(SCREAMING_SNAKE_CASE_	)
											model.to(SCREAMING_SNAKE_CASE_	)
											model.eval()
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)
											self.parent.assertEqual(
											    result.logits.shape ,							(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)	)
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_ ,							labels=SCREAMING_SNAKE_CASE_	)
											self.parent.assertEqual(
											    result.logits.shape ,							(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)	)
											self.parent.assertGreater(result.loss ,							0.0	)




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   List[str]	):
											lowerCAmelCase__      			=						1
											lowerCAmelCase__      			=						SegformerForSemanticSegmentation(config=SCREAMING_SNAKE_CASE_	)
											model.to(SCREAMING_SNAKE_CASE_	)
											model.eval()
											lowerCAmelCase__      			=						torch.randint(0 ,							1 ,							(self.batch_size, self.image_size, self.image_size)	).to(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_ ,							labels=SCREAMING_SNAKE_CASE_	)
											self.parent.assertGreater(result.loss ,							0.0	)




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						self.prepare_config_and_inputs()
											lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						config_and_inputs
											lowerCAmelCase__      			=						{'''pixel_values''': pixel_values}
											return config, inputs_dict



@require_torch
class  lowerCAmelCase_       (				snake_case__     ,    snake_case__     ,    unittest.TestCase					):
							UpperCamelCase_		:Any		      =    (
							    (
							        SegformerModel,
							        SegformerForSemanticSegmentation,
							        SegformerForImageClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							UpperCamelCase_		:Union[str, Any]		      =    (
							    {
							        'feature-extraction': SegformerModel,
							        'image-classification': SegformerForImageClassification,
							        'image-segmentation': SegformerForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							UpperCamelCase_		:Any		      =    True
							UpperCamelCase_		:Dict		      =    False
							UpperCamelCase_		:Tuple		      =    False
							UpperCamelCase_		:int		      =    False




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						SegformerModelTester(self	)
											lowerCAmelCase__      			=						SegformerConfigTester(self ,							config_class=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   List[str]	):
											self.config_tester.run_common_tests()




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_binary_image_segmentation(*SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_segmentation(*SCREAMING_SNAKE_CASE_	)




							@unittest.skip('''SegFormer does not use inputs_embeds'''	)
							def 						__snake_case					(   self     :   Dict	):
											pass




							@unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods'''	)
							def 						__snake_case					(   self     :   int	):
											pass




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()

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

															lowerCAmelCase__      			=						['''pixel_values''']
															self.assertListEqual(arg_names[:1] ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Union[str, Any]	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()
											lowerCAmelCase__      			=						True

											for model_class in self.all_model_classes:
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						False
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															model.to(SCREAMING_SNAKE_CASE_	)
															model.eval()
															with torch.no_grad():
																			lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)	)
															lowerCAmelCase__      			=						outputs.attentions

															lowerCAmelCase__      			=						sum(self.model_tester.depths	)
															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							SCREAMING_SNAKE_CASE_	)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															model.to(SCREAMING_SNAKE_CASE_	)
															model.eval()
															with torch.no_grad():
																			lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)	)
															lowerCAmelCase__      			=						outputs.attentions

															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							SCREAMING_SNAKE_CASE_	)

															# verify the first attentions (first block, first layer)
															lowerCAmelCase__      			=						(self.model_tester.image_size // 4) ** 2
															lowerCAmelCase__      			=						(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
															self.assertListEqual(
															    list(attentions[0].shape[-3:]	) ,							[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len] ,							)

															# verify the last attentions (last block, last layer)
															lowerCAmelCase__      			=						(self.model_tester.image_size // 32) ** 2
															lowerCAmelCase__      			=						(self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
															self.assertListEqual(
															    list(attentions[-1].shape[-3:]	) ,							[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len] ,							)
															lowerCAmelCase__      			=						len(SCREAMING_SNAKE_CASE_	)

															# Check attention is always last and order is fine
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															model.to(SCREAMING_SNAKE_CASE_	)
															model.eval()
															with torch.no_grad():
																			lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)	)

															self.assertEqual(out_len + 1 ,							len(SCREAMING_SNAKE_CASE_	)	)

															lowerCAmelCase__      			=						outputs.attentions

															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							SCREAMING_SNAKE_CASE_	)
															# verify the first attentions (first block, first layer)
															lowerCAmelCase__      			=						(self.model_tester.image_size // 4) ** 2
															lowerCAmelCase__      			=						(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
															self.assertListEqual(
															    list(self_attentions[0].shape[-3:]	) ,							[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len] ,							)




							def 						__snake_case					(   self     :   Dict	):
											def check_hidden_states_output(SCREAMING_SNAKE_CASE_     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   Any	):
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															model.to(SCREAMING_SNAKE_CASE_	)
															model.eval()

															with torch.no_grad():
																			lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)	)

															lowerCAmelCase__      			=						outputs.hidden_states

															lowerCAmelCase__      			=						self.model_tester.num_encoder_blocks
															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							SCREAMING_SNAKE_CASE_	)

															# verify the first hidden states (first block)
															self.assertListEqual(
															    list(hidden_states[0].shape[-3:]	) ,							[
															        self.model_tester.hidden_sizes[0],
															        self.model_tester.image_size // 4,
															        self.model_tester.image_size // 4,
															    ] ,							)

											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															lowerCAmelCase__      			=						True
															check_hidden_states_output(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															lowerCAmelCase__      			=						True

															check_hidden_states_output(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Any	):
											if not self.model_tester.is_training:
															return

											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()
											lowerCAmelCase__      			=						True

											for model_class in self.all_model_classes:
															if model_class in get_values(SCREAMING_SNAKE_CASE_	):
																			continue

															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															model.to(SCREAMING_SNAKE_CASE_	)
															model.train()
															lowerCAmelCase__      			=						self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							return_labels=SCREAMING_SNAKE_CASE_	)
															lowerCAmelCase__      			=						model(**SCREAMING_SNAKE_CASE_	).loss
															loss.backward()




							@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''	)
							def 						__snake_case					(   self     :   Dict	):
											pass




							@slow
							def 						__snake_case					(   self     :   Any	):
											for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowerCAmelCase__      			=						SegformerModel.from_pretrained(SCREAMING_SNAKE_CASE_	)
															self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)





def 	lowerCAmelCase_		()		->    int:


				'''simple docstring'''




				lowerCAmelCase__      			=						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
				return image




@require_torch
class  lowerCAmelCase_       (				unittest.TestCase					):




							@slow
							def 						__snake_case					(   self     :   List[str]	):
											# only resize + normalize
											lowerCAmelCase__      			=						SegformerImageProcessor(
											    image_scale=(512, 512) ,							keep_ratio=SCREAMING_SNAKE_CASE_ ,							align=SCREAMING_SNAKE_CASE_ ,							do_random_crop=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''	).to(
											    SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						prepare_img()
											lowerCAmelCase__      			=						image_processor(images=SCREAMING_SNAKE_CASE_ ,							return_tensors='''pt'''	)
											lowerCAmelCase__      			=						encoded_inputs.pixel_values.to(SCREAMING_SNAKE_CASE_	)

											with torch.no_grad():
															lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						torch.Size((1, model.config.num_labels, 128, 128)	)
											self.assertEqual(outputs.logits.shape ,							SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						torch.tensor(
											    [
											        [[-4.6_310, -5.5_232, -6.2_356], [-5.1_921, -6.1_444, -6.5_996], [-5.4_424, -6.2_790, -6.7_574]],
											        [[-12.1_391, -13.3_122, -13.9_554], [-12.8_732, -13.9_352, -14.3_563], [-12.9_438, -13.8_226, -14.2_513]],
											        [[-12.5_134, -13.4_686, -14.4_915], [-12.8_669, -14.4_343, -14.7_758], [-13.2_523, -14.5_819, -15.0_694]],
											    ]	).to(SCREAMING_SNAKE_CASE_	)
											self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=1e-4	)	)




							@slow
							def 						__snake_case					(   self     :   Tuple	):
											# only resize + normalize
											lowerCAmelCase__      			=						SegformerImageProcessor(
											    image_scale=(512, 512) ,							keep_ratio=SCREAMING_SNAKE_CASE_ ,							align=SCREAMING_SNAKE_CASE_ ,							do_random_crop=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						SegformerForSemanticSegmentation.from_pretrained(
											    '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024'''	).to(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						prepare_img()
											lowerCAmelCase__      			=						image_processor(images=SCREAMING_SNAKE_CASE_ ,							return_tensors='''pt'''	)
											lowerCAmelCase__      			=						encoded_inputs.pixel_values.to(SCREAMING_SNAKE_CASE_	)

											with torch.no_grad():
															lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						torch.Size((1, model.config.num_labels, 128, 128)	)
											self.assertEqual(outputs.logits.shape ,							SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						torch.tensor(
											    [
											        [[-13.5_748, -13.9_111, -12.6_500], [-14.3_500, -15.3_683, -14.2_328], [-14.7_532, -16.0_424, -15.6_087]],
											        [[-17.1_651, -15.8_725, -12.9_653], [-17.2_580, -17.3_718, -14.8_223], [-16.6_058, -16.8_783, -16.7_452]],
											        [[-3.6_456, -3.0_209, -1.4_203], [-3.0_797, -3.1_959, -2.0_000], [-1.8_757, -1.9_217, -1.6_997]],
											    ]	).to(SCREAMING_SNAKE_CASE_	)
											self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=1e-1	)	)




							@slow
							def 						__snake_case					(   self     :   Dict	):
											# only resize + normalize
											lowerCAmelCase__      			=						SegformerImageProcessor(
											    image_scale=(512, 512) ,							keep_ratio=SCREAMING_SNAKE_CASE_ ,							align=SCREAMING_SNAKE_CASE_ ,							do_random_crop=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''	).to(
											    SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						prepare_img()
											lowerCAmelCase__      			=						image_processor(images=SCREAMING_SNAKE_CASE_ ,							return_tensors='''pt'''	)
											lowerCAmelCase__      			=						encoded_inputs.pixel_values.to(SCREAMING_SNAKE_CASE_	)

											with torch.no_grad():
															lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						outputs.logits.detach().cpu()

											lowerCAmelCase__      			=						image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE_ ,							target_sizes=[(500, 300)]	)
											lowerCAmelCase__      			=						torch.Size((500, 300)	)
											self.assertEqual(segmentation[0].shape ,							SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						torch.Size((128, 128)	)
											self.assertEqual(segmentation[0].shape ,							SCREAMING_SNAKE_CASE_	)













from typing import TYPE_CHECKING

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


_UpperCAmelCase			:		str   				=    {
    "configuration_blenderbot_small": [
        "BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "BlenderbotSmallConfig",
        "BlenderbotSmallOnnxConfig",
    ],
    "tokenization_blenderbot_small": ["BlenderbotSmallTokenizer"],
}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		List[str]   				=    ["BlenderbotSmallTokenizerFast"]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		List[str]   				=    [
			    "BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "BlenderbotSmallForCausalLM",
			    "BlenderbotSmallForConditionalGeneration",
			    "BlenderbotSmallModel",
			    "BlenderbotSmallPreTrainedModel",
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		Dict   				=    [
			    "TFBlenderbotSmallForConditionalGeneration",
			    "TFBlenderbotSmallModel",
			    "TFBlenderbotSmallPreTrainedModel",
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		List[str]   				=    [
			    "FlaxBlenderbotSmallForConditionalGeneration",
			    "FlaxBlenderbotSmallModel",
			    "FlaxBlenderbotSmallPreTrainedModel",
			]

if TYPE_CHECKING:
			from .configuration_blenderbot_small import (
			    BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    BlenderbotSmallConfig,
			    BlenderbotSmallOnnxConfig,
			)
			from .tokenization_blenderbot_small import BlenderbotSmallTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_blenderbot_small_fast import BlenderbotSmallTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_blenderbot_small import (
						    BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST,
						    BlenderbotSmallForCausalLM,
						    BlenderbotSmallForConditionalGeneration,
						    BlenderbotSmallModel,
						    BlenderbotSmallPreTrainedModel,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_blenderbot_small import (
						    TFBlenderbotSmallForConditionalGeneration,
						    TFBlenderbotSmallModel,
						    TFBlenderbotSmallPreTrainedModel,
						)

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_flax_blenderbot_small import (
						    FlaxBlenderbotSmallForConditionalGeneration,
						    FlaxBlenderbotSmallModel,
						    FlaxBlenderbotSmallPreTrainedModel,
						)

else:
			import sys

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





