
import inspect
import unittest

from transformers import EfficientNetConfig
from transformers.testing_utils import is_pipeline_test, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 EfficientNetForImageClassification, EfficientNetModel
					from transformers.models.efficientnet.modeling_efficientnet import EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor


class 							lowercase   :



		def __init__(					self							, A_							, A_=13							, A_=32							, A_=3							, A_=[3, 3, 5]							, A_=[32, 16, 24]							, A_=[16, 24, 40]							, A_=[1, 1, 2]							, A_=[1, 1, 2]							, A_=[1, 6, 6]							, A_=True							, A_=True							, A_=37							, A_="gelu"							, A_=10							, )    ->   str:
				"""simple docstring"""
				UpperCamelCase            =	parent
				UpperCamelCase            =	batch_size
				UpperCamelCase            =	image_size
				UpperCamelCase            =	num_channels
				UpperCamelCase            =	kernel_sizes
				UpperCamelCase            =	in_channels
				UpperCamelCase            =	out_channels
				UpperCamelCase            =	strides
				UpperCamelCase            =	num_block_repeats
				UpperCamelCase            =	expand_ratios
				UpperCamelCase            =	is_training
				UpperCamelCase            =	hidden_act
				UpperCamelCase            =	num_labels
				UpperCamelCase            =	use_labels



		def __UpperCamelCase					(					self			)    ->   str:
				"""simple docstring"""
				UpperCamelCase            =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

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



		def __UpperCamelCase					(					self			)    ->   List[Any]:
				"""simple docstring"""
				return EfficientNetConfig(
				    num_channels=self.num_channels							, kernel_sizes=self.kernel_sizes							, in_channels=self.in_channels							, out_channels=self.out_channels							, strides=self.strides							, num_block_repeats=self.num_block_repeats							, expand_ratios=self.expand_ratios							, hidden_act=self.hidden_act							, num_labels=self.num_labels							, )



		def __UpperCamelCase					(					self							, A_							, A_							, A_			)    ->   int:
				"""simple docstring"""
				UpperCamelCase            =	EfficientNetModel(config=A_			)
				model.to(A_			)
				model.eval()
				UpperCamelCase            =	model(A_			)
				# expected last hidden states: B, C, H // 4, W // 4
				self.parent.assertEqual(
				    result.last_hidden_state.shape							, (self.batch_size, config.hidden_dim, self.image_size // 4, self.image_size // 4)							, )



		def __UpperCamelCase					(					self							, A_							, A_							, A_			)    ->   int:
				"""simple docstring"""
				UpperCamelCase            =	EfficientNetForImageClassification(A_			)
				model.to(A_			)
				model.eval()
				UpperCamelCase            =	model(A_							, labels=A_			)
				self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)			)



		def __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				UpperCamelCase            =	self.prepare_config_and_inputs()
				UpperCamelCase      ,    UpperCamelCase      ,    UpperCamelCase            =	config_and_inputs
				UpperCamelCase            =	{'pixel_values': pixel_values}
				return config, inputs_dict






@require_torch
class 							lowercase   (						_SCREAMING_SNAKE_CASE    ,  _SCREAMING_SNAKE_CASE    ,  unittest.TestCase  ):
		__lowercase			:			Dict      	=							(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
		__lowercase			:			Dict      	=							(
		    {"feature-extraction": EfficientNetModel, "image-classification": EfficientNetForImageClassification}
		    if is_torch_available()
		    else {}
		)

		__lowercase			:			int      	=							False
		__lowercase			:			Optional[int]      	=							False
		__lowercase			:			Optional[Any]      	=							False
		__lowercase			:			Any      	=							False
		__lowercase			:			str      	=							False



		def __UpperCamelCase					(					self			)    ->   Dict:
				"""simple docstring"""
				UpperCamelCase            =	EfficientNetModelTester(self			)
				UpperCamelCase            =	ConfigTester(
				    self							, config_class=A_							, has_text_modality=A_							, hidden_size=37			)



		def __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				self.create_and_test_config_common_properties()
				self.config_tester.create_and_test_config_to_json_string()
				self.config_tester.create_and_test_config_to_json_file()
				self.config_tester.create_and_test_config_from_and_save_pretrained()
				self.config_tester.create_and_test_config_with_num_labels()
				self.config_tester.check_config_can_be_init_without_params()
				self.config_tester.check_config_arguments_init()



		def __UpperCamelCase					(					self			)    ->   str:
				"""simple docstring"""
				return



		@unittest.skip(reason='EfficientNet does not use inputs_embeds'			)
		def __UpperCamelCase					(					self			)    ->   List[Any]:
				"""simple docstring"""
				pass



		@unittest.skip(reason='EfficientNet does not support input and output embeddings'			)
		def __UpperCamelCase					(					self			)    ->   Union[str, Any]:
				"""simple docstring"""
				pass



		@unittest.skip(reason='EfficientNet does not use feedforward chunking'			)
		def __UpperCamelCase					(					self			)    ->   int:
				"""simple docstring"""
				pass



		def __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				UpperCamelCase      ,    UpperCamelCase            =	self.model_tester.prepare_config_and_inputs_for_common()

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

						UpperCamelCase            =	['pixel_values']
						self.assertListEqual(arg_names[:1]							, A_			)



		def __UpperCamelCase					(					self			)    ->   Optional[Any]:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*A_			)



		def __UpperCamelCase					(					self			)    ->   int:
				"""simple docstring"""
				def check_hidden_states_output(A_							, A_							, A_			):
						UpperCamelCase            =	model_class(A_			)
						model.to(A_			)
						model.eval()

						with torch.no_grad():
								UpperCamelCase            =	model(**self._prepare_for_class(A_							, A_			)			)

						UpperCamelCase            =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
						UpperCamelCase            =	sum(config.num_block_repeats			) * 4
						self.assertEqual(len(A_			)							, A_			)

						# EfficientNet's feature maps are of shape (batch_size, num_channels, height, width)
						self.assertListEqual(
						    list(hidden_states[0].shape[-2:]			)							, [self.model_tester.image_size // 2, self.model_tester.image_size // 2]							, )

				UpperCamelCase      ,    UpperCamelCase            =	self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						UpperCamelCase            =	True
						check_hidden_states_output(A_							, A_							, A_			)

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

						check_hidden_states_output(A_							, A_							, A_			)



		def __UpperCamelCase					(					self			)    ->   List[str]:
				"""simple docstring"""
				UpperCamelCase            =	self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*A_			)



		@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'			)
		def __UpperCamelCase					(					self			)    ->   Dict:
				"""simple docstring"""
				pass



		@slow
		def __UpperCamelCase					(					self			)    ->   Any:
				"""simple docstring"""
				for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase            =	EfficientNetModel.from_pretrained(A_			)
						self.assertIsNotNone(A_			)



		@is_pipeline_test
		@require_vision
		@slow
		def __UpperCamelCase					(					self			)    ->   Dict:
				"""simple docstring"""
				super().test_pipeline_image_classification()






def  A			(   )  ->    Optional[int]:
		'''simple docstring'''

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


@require_torch
@require_vision
class 							lowercase   (						unittest.TestCase  ):



		@cached_property
		def __UpperCamelCase					(					self			)    ->   Optional[Any]:
				"""simple docstring"""
				return AutoImageProcessor.from_pretrained('google/efficientnet-b7'			) if is_vision_available() else None



		@slow
		def __UpperCamelCase					(					self			)    ->   Optional[Any]:
				"""simple docstring"""
				UpperCamelCase            =	EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7'			).to(A_			)

				UpperCamelCase            =	self.default_image_processor
				UpperCamelCase            =	prepare_img()
				UpperCamelCase            =	image_processor(images=A_							, return_tensors='pt'			).to(A_			)

				# forward pass
				with torch.no_grad():
						UpperCamelCase            =	model(**A_			)

				# verify the logits
				UpperCamelCase            =	torch.Size((1, 1_000)			)
				self.assertEqual(outputs.logits.shape							, A_			)

				UpperCamelCase            =	torch.tensor([0.0001, 0.0002, 0.0002]			).to(A_			)
				self.assertTrue(torch.allclose(outputs.logits[0, :3]							, A_							, atol=1e-4			)			)


from __future__ import annotations


def  A			(   lowercase       ,			lowercase					)  ->    int:
		'''simple docstring'''

		UpperCamelCase      ,    UpperCamelCase            =	0, len(lowercase					) - 1
		while start_ind <= end_ind:
				if array[start_ind] == search_item:
						return start_ind
				elif array[end_ind] == search_item:
						return end_ind
				else:
						start_ind += 1
						end_ind -= 1
    # returns -1 if search_item is not found in array
		return -1


if __name__ == "__main__":
					print(double_linear_search(list(range(100)), 40))
