



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 lowerCAmelCase_       :







	'''simple docstring'''




	def __init__(	self   ,       lowerCamelCase   ,       lowerCamelCase=13   ,       lowerCamelCase=32   ,       lowerCamelCase=3   ,       lowerCamelCase=[3, 3, 5]   ,       lowerCamelCase=[32, 16, 24]   ,       lowerCamelCase=[16, 24, 40]   ,       lowerCamelCase=[1, 1, 2]   ,       lowerCamelCase=[1, 1, 2]   ,       lowerCamelCase=[1, 6, 6]   ,       lowerCamelCase=True   ,       lowerCamelCase=True   ,       lowerCamelCase=37   ,       lowerCamelCase="gelu"   ,       lowerCamelCase=10   ,       ):



				'''simple docstring'''


				a__					=  parent
				a__					=  batch_size
				a__					=  image_size
				a__					=  num_channels
				a__					=  kernel_sizes
				a__					=  in_channels
				a__					=  out_channels
				a__					=  strides
				a__					=  num_block_repeats
				a__					=  expand_ratios
				a__					=  is_training
				a__					=  hidden_act
				a__					=  num_labels
				a__					=  use_labels

	def 				_A			(	self       ):



				'''simple docstring'''


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

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

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

	def 				_A			(	self       ):



				'''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 				_A			(	self   ,       lowerCamelCase   ,       lowerCamelCase   ,       lowerCamelCase       ):



				'''simple docstring'''


				a__					=  EfficientNetModel(config=_A       )
				model.to(_A       )
				model.eval()
				a__					=  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 				_A			(	self   ,       lowerCamelCase   ,       lowerCamelCase   ,       lowerCamelCase       ):



				'''simple docstring'''


				a__					=  EfficientNetForImageClassification(_A       )
				model.to(_A       )
				model.eval()
				a__					=  model(_A   ,       labels=_A       )
				self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.num_labels)       )







	def 				_A			(	self       ):



				'''simple docstring'''


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


@require_torch
class lowerCAmelCase_       (   __SCREAMING_SNAKE_CASE ,__SCREAMING_SNAKE_CASE ,unittest.TestCase			):







	'''simple docstring'''




	A_       :     int									=		(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
	A_       :     Dict									=		(
	    {'feature-extraction': EfficientNetModel, 'image-classification': EfficientNetForImageClassification}
	    if is_torch_available()
	    else {}
	)

	A_       :     Any									=		False
	A_       :     Any									=		False
	A_       :     Any									=		False
	A_       :     List[str]									=		False
	A_       :     Dict									=		False

	def 				_A			(	self       ):



				'''simple docstring'''


				a__					=  EfficientNetModelTester(self       )
				a__					=  ConfigTester(
				    self   ,       config_class=_A   ,       has_text_modality=_A   ,       hidden_size=37       )

	def 				_A			(	self       ):



				'''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 				_A			(	self       ):



				'''simple docstring'''


				return

	@unittest.skip(reason="""EfficientNet does not use inputs_embeds"""       )
	def 				_A			(	self       ):



				'''simple docstring'''


				pass

	@unittest.skip(reason="""EfficientNet does not support input and output embeddings"""       )
	def 				_A			(	self       ):



				'''simple docstring'''


				pass

	@unittest.skip(reason="""EfficientNet does not use feedforward chunking"""       )
	def 				_A			(	self       ):



				'''simple docstring'''


				pass

	def 				_A			(	self       ):



				'''simple docstring'''


				a__				,       a__					=  self.model_tester.prepare_config_and_inputs_for_common()

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

							a__					=  ["""pixel_values"""]
							self.assertListEqual(arg_names[:1]   ,       _A       )

	def 				_A			(	self       ):



				'''simple docstring'''


				a__					=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_A       )

	def 				_A			(	self       ):



				'''simple docstring'''


				def check_hidden_states_output(lowerCamelCase   ,       lowerCamelCase   ,       lowerCamelCase       ):
							a__					=  model_class(_A       )
							model.to(_A       )
							model.eval()

							with torch.no_grad():
										a__					=  model(**self._prepare_for_class(_A   ,       _A       )       )

							a__					=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
							a__					=  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]   ,       )

				a__				,       a__					=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							a__					=  True
							check_hidden_states_output(_A   ,       _A   ,       _A       )

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

							check_hidden_states_output(_A   ,       _A   ,       _A       )

	def 				_A			(	self       ):



				'''simple docstring'''


				a__					=  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 				_A			(	self       ):



				'''simple docstring'''


				pass

	@slow
	def 				_A			(	self       ):



				'''simple docstring'''


				for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							a__					=  EfficientNetModel.from_pretrained(_A       )
							self.assertIsNotNone(_A       )







	@is_pipeline_test
	@require_vision
	@slow
	def 				_A			(	self       ):



				'''simple docstring'''


				super().test_pipeline_image_classification()




def    UpperCAmelCase					(  ):



			'''simple docstring'''





			a__					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
			return image





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







	'''simple docstring'''




	@cached_property
	def 				_A			(	self       ):



				'''simple docstring'''


				return AutoImageProcessor.from_pretrained("""google/efficientnet-b7"""       ) if is_vision_available() else None







	@slow
	def 				_A			(	self       ):



				'''simple docstring'''


				a__					=  EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""       ).to(_A       )

				a__					=  self.default_image_processor
				a__					=  prepare_img()
				a__					=  image_processor(images=_A   ,       return_tensors="""pt"""       ).to(_A       )

				# forward pass
				with torch.no_grad():
							a__					=  model(**_A       )

				# verify the logits
				a__					=  torch.Size((1, 1000)       )
				self.assertEqual(outputs.logits.shape   ,       _A       )

				a__					=  torch.tensor([0.0_0_0_1, 0.0_0_0_2, 0.0_0_0_2]       ).to(_A       )
				self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,       _A   ,       atol=1e-4       )       )



from __future__ import annotations

from collections.abc import Iterable





class 				UpperCamelCase__		:






       """simple docstring"""


       def __init__(							self ,     _A ,     _A	)				->				Union[str, Any]:
          SCREAMING_SNAKE_CASE_	, SCREAMING_SNAKE_CASE_	=      float(_A	), float(_A	)



       def __eq__(							self ,     _A	)				->				str:
          return self.x == other.x and self.y == other.y



       def __ne__(							self ,     _A	)				->				Any:
          return not self == other



       def __gt__(							self ,     _A	)				->				List[Any]:
          if self.x > other.x:
             return True
          elif self.x == other.x:
             return self.y > other.y
          return False



       def __lt__(							self ,     _A	)				->				Optional[int]:
          return not self > other



       def __ge__(							self ,     _A	)				->				int:
          if self.x > other.x:
             return True
          elif self.x == other.x:
             return self.y >= other.y
          return False



       def __le__(							self ,     _A	)				->				str:
          if self.x < other.x:
             return True
          elif self.x == other.x:
             return self.y <= other.y
          return False



       def __repr__(							self	)				->				str:
          return F'''({self.x}, {self.y})'''




       def __hash__(							self	)				->				List[str]:
          return hash(self.x	)







def  A__ (       __lowerCamelCase,  ):
   SCREAMING_SNAKE_CASE_	=      []
   if list_of_tuples:
      for p in list_of_tuples:
         if isinstance(__lowerCamelCase,  __lowerCamelCase						):
            points.append(__lowerCamelCase						)
         else:
            try:
               points.append(Point(p[0],  p[1]						)						)
            except (IndexError, TypeError):
               print(
                   F'''Ignoring deformed point {p}. All points'''
                   ''' must have at least 2 coordinates.'''						)
   return points


def  A__ (       __lowerCamelCase						):

   if not hasattr(__lowerCamelCase,  '''__iter__'''						):
      SCREAMING_SNAKE_CASE_	=      F'''Expecting an iterable object but got an non-iterable type {points}'''
      raise ValueError(__lowerCamelCase						)

   if not points:
      SCREAMING_SNAKE_CASE_	=      F'''Expecting a list of points but got {points}'''
      raise ValueError(__lowerCamelCase						)

   return _construct_points(__lowerCamelCase						)


def  A__ (       __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      (a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
   return det


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      sorted(_validate_input(__lowerCamelCase						)						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      set()

   for i in range(n - 1						):
      for j in range(i + 1,  __lowerCamelCase						):
         SCREAMING_SNAKE_CASE_	=      SCREAMING_SNAKE_CASE_	=      False
         SCREAMING_SNAKE_CASE_	=      True
         for k in range(__lowerCamelCase						):
            if k != i and k != j:
               SCREAMING_SNAKE_CASE_	=      _det(points[i],  points[j],  points[k]						)

               if det_k > 0:
                  SCREAMING_SNAKE_CASE_	=      True
               elif det_k < 0:
                  SCREAMING_SNAKE_CASE_	=      True
               else:
                  # point[i], point[j], point[k] all lie on a straight line
                  # if point[k] is to the left of point[i] or it's to the
                  # right of point[j], then point[i], point[j] cannot be
                  # part of the convex hull of A
                  if points[k] < points[i] or points[k] > points[j]:
                     SCREAMING_SNAKE_CASE_	=      False
                     break

            if points_left_of_ij and points_right_of_ij:
               SCREAMING_SNAKE_CASE_	=      False
               break

         if ij_part_of_convex_hull:
            convex_set.update([points[i], points[j]]						)

   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      sorted(_validate_input(__lowerCamelCase						)						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)

   # divide all the points into an upper hull and a lower hull
   # the left most point and the right most point are definitely
   # members of the convex hull by definition.
   # use these two anchors to divide all the points into two hulls,
   # an upper hull and a lower hull.

   # all points to the left (above) the line joining the extreme points belong to the
   # upper hull
   # all points to the right (below) the line joining the extreme points below to the
   # lower hull
   # ignore all points on the line joining the extreme points since they cannot be
   # part of the convex hull

   SCREAMING_SNAKE_CASE_	=      points[0]
   SCREAMING_SNAKE_CASE_	=      points[n - 1]

   SCREAMING_SNAKE_CASE_	=      {left_most_point, right_most_point}
   SCREAMING_SNAKE_CASE_	=      []
   SCREAMING_SNAKE_CASE_	=      []

   for i in range(1,  n - 1						):
      SCREAMING_SNAKE_CASE_	=      _det(__lowerCamelCase,  __lowerCamelCase,  points[i]						)

      if det > 0:
         upper_hull.append(points[i]						)
      elif det < 0:
         lower_hull.append(points[i]						)

   _construct_hull(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)
   _construct_hull(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)

   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						):
   if points:
      SCREAMING_SNAKE_CASE_	=      None
      SCREAMING_SNAKE_CASE_	=      float('''-inf'''						)
      SCREAMING_SNAKE_CASE_	=      []

      for p in points:
         SCREAMING_SNAKE_CASE_	=      _det(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)

         if det > 0:
            candidate_points.append(__lowerCamelCase						)

            if det > extreme_point_distance:
               SCREAMING_SNAKE_CASE_	=      det
               SCREAMING_SNAKE_CASE_	=      p

      if extreme_point:
         _construct_hull(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)
         convex_set.add(__lowerCamelCase						)
         _construct_hull(__lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase,  __lowerCamelCase						)


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      sorted(_validate_input(__lowerCamelCase						)						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)

   SCREAMING_SNAKE_CASE_	=      points[:2]
   for i in range(2,  __lowerCamelCase						):
      SCREAMING_SNAKE_CASE_	=      _det(convex_hull[1],  convex_hull[0],  points[i]						)
      if det > 0:
         convex_hull.insert(0,  points[i]						)
         break
      elif det < 0:
         convex_hull.append(points[i]						)
         break
      else:
         SCREAMING_SNAKE_CASE_	=      points[i]
   i += 1

   for j in range(__lowerCamelCase,  __lowerCamelCase						):
      if (
          _det(convex_hull[0],  convex_hull[-1],  points[j]						) > 0
          and _det(convex_hull[-1],  convex_hull[0],  points[1]						) < 0
      ):
         # The point lies within the convex hull
         continue

      convex_hull.insert(0,  points[j]						)
      convex_hull.append(points[j]						)
      while _det(convex_hull[0],  convex_hull[1],  convex_hull[2]						) >= 0:
         del convex_hull[1]
      while _det(convex_hull[-1],  convex_hull[-2],  convex_hull[-3]						) <= 0:
         del convex_hull[-2]

    # `convex_hull` is contains the convex hull in circular order
   return sorted(convex_hull[1:] if len(__lowerCamelCase						) > 3 else convex_hull						)


def  A__ (       ):
   SCREAMING_SNAKE_CASE_	=      [
       (0, 3),
       (2, 2),
       (1, 1),
       (2, 1),
       (3, 0),
       (0, 0),
       (3, 3),
       (2, -1),
       (2, -4),
       (1, -3),
   ]
   # the convex set of points is
   # [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
   SCREAMING_SNAKE_CASE_	=      convex_hull_bf(__lowerCamelCase						)

   SCREAMING_SNAKE_CASE_	=      convex_hull_recursive(__lowerCamelCase						)
   assert results_bf == results_recursive

   SCREAMING_SNAKE_CASE_	=      convex_hull_melkman(__lowerCamelCase						)
   assert results_bf == results_melkman

   print(__lowerCamelCase						)


if __name__ == "__main__":
   main()


