



import inspect
import unittest

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

from ...test_backbone_common import BackboneTesterMixin
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 ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
	from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor

class  __snake_case      :







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_=13  ,  a_=32  ,  a_=3  ,  a_=4  ,  a_=[10, 20, 30, 40]  ,  a_=[2, 2, 3, 2]  ,  a_=True  ,  a_=True  ,  a_=37  ,  a_="gelu"  ,  a_=10  ,  a_=0.02  ,  a_=["stage2", "stage3", "stage4"]  ,  a_=[2, 3, 4]  ,  a_=None  ,  ):
											a__				      =		parent
											a__				      =		batch_size
											a__				      =		image_size
											a__				      =		num_channels
											a__				      =		num_stages
											a__				      =		hidden_sizes
											a__				      =		depths
											a__				      =		is_training
											a__				      =		use_labels
											a__				      =		intermediate_size
											a__				      =		hidden_act
											a__				      =		num_labels
											a__				      =		initializer_range
											a__				      =		out_features
											a__				      =		out_indices
											a__				      =		scope


							def _a      (							self		):
											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		):
											return ConvNextConfig(
											    num_channels=self.num_channels  ,  hidden_sizes=self.hidden_sizes  ,  depths=self.depths  ,  num_stages=self.num_stages  ,  hidden_act=self.hidden_act  ,  is_decoder=a_  ,  initializer_range=self.initializer_range  ,  out_features=self.out_features  ,  out_indices=self.out_indices  ,  num_labels=self.num_labels  ,  )


							def _a      (							self  ,  a_  ,  a_  ,  a_		):
											a__				      =		ConvNextModel(config=a_		)
											model.to(a_		)
											model.eval()
											a__				      =		model(a_		)
											# expected last hidden states: B, C, H // 32, W // 32
											self.parent.assertEqual(
											    result.last_hidden_state.shape  ,  (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)  ,  )


							def _a      (							self  ,  a_  ,  a_  ,  a_		):
											a__				      =		ConvNextForImageClassification(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  ,  a_  ,  a_  ,  a_		):
											a__				      =		ConvNextBackbone(config=a_		)
											model.to(a_		)
											model.eval()
											a__				      =		model(a_		)

											# verify hidden states
											self.parent.assertEqual(len(result.feature_maps		)  ,  len(config.out_features		)		)
											self.parent.assertListEqual(list(result.feature_maps[0].shape		)  ,  [self.batch_size, self.hidden_sizes[1], 4, 4]		)

											# verify channels
											self.parent.assertEqual(len(model.channels		)  ,  len(config.out_features		)		)
											self.parent.assertListEqual(model.channels  ,  config.hidden_sizes[1:]		)

											# verify backbone works with out_features=None
											a__				      =		None
											a__				      =		ConvNextBackbone(config=a_		)
											model.to(a_		)
											model.eval()
											a__				      =		model(a_		)

											# verify feature maps
											self.parent.assertEqual(len(result.feature_maps		)  ,  1		)
											self.parent.assertListEqual(list(result.feature_maps[0].shape		)  ,  [self.batch_size, self.hidden_sizes[-1], 1, 1]		)

											# verify channels
											self.parent.assertEqual(len(model.channels		)  ,  1		)
											self.parent.assertListEqual(model.channels  ,  [config.hidden_sizes[-1]]		)







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




@require_torch
class  __snake_case      (   SCREAMING_SNAKE_CASE			,SCREAMING_SNAKE_CASE			,unittest.TestCase):







							'''simple docstring'''






							UpperCamelCase__         =					(
							    (
							        ConvNextModel,
							        ConvNextForImageClassification,
							        ConvNextBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							UpperCamelCase__         =					(
							    {"""feature-extraction""": ConvNextModel, """image-classification""": ConvNextForImageClassification}
							    if is_torch_available()
							    else {}
							)

							UpperCamelCase__         =					True
							UpperCamelCase__         =					False
							UpperCamelCase__         =					False
							UpperCamelCase__         =					False
							UpperCamelCase__         =					False


							def _a      (							self		):
											a__				      =		ConvNextModelTester(self		)
											a__				      =		ConfigTester(self  ,  config_class=a_  ,  has_text_modality=a_  ,  hidden_size=37		)


							def _a      (							self		):
											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		):
											return


							@unittest.skip(reason="""ConvNext does not use inputs_embeds"""		)
							def _a      (							self		):
											pass


							@unittest.skip(reason="""ConvNext does not support input and output embeddings"""		)
							def _a      (							self		):
											pass


							@unittest.skip(reason="""ConvNext does not use feedforward chunking"""		)
							def _a      (							self		):
											pass


							def _a      (							self		):
											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		):
											a__				      =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*a_		)


							def _a      (							self		):
											a__				      =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_backbone(*a_		)


							def _a      (							self		):
											def check_hidden_states_output(a_  ,  a_  ,  a_		):
															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__				      =		self.model_tester.num_stages
															self.assertEqual(len(a_		)  ,  expected_num_stages + 1		)

															# ConvNext'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 // 4, self.model_tester.image_size // 4]  ,  )

											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		):
											a__				      =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*a_		)







							@slow
							def _a      (							self		):
											for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															a__				      =		ConvNextModel.from_pretrained(a_		)
															self.assertIsNotNone(a_		)




def 			A_      (	):

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

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







							'''simple docstring'''






							@cached_property
							def _a      (							self		):
											return AutoImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""		) if is_vision_available() else None







							@slow
							def _a      (							self		):
											a__				      =		ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""		).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, 1_000)		)
											self.assertEqual(outputs.logits.shape  ,  a_		)

											a__				      =		torch.tensor([-0.0_260, -0.4_739, 0.1_911]		).to(a_		)

											self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,  a_  ,  atol=1E-4		)		)




@require_torch
class  __snake_case      (   unittest.TestCase			,SCREAMING_SNAKE_CASE):







							'''simple docstring'''






							UpperCamelCase__         =					(ConvNextBackbone,) if is_torch_available() else ()
							UpperCamelCase__         =					ConvNextConfig

							UpperCamelCase__         =					False


							def _a      (							self		):
											a__				      =		ConvNextModelTester(self		)






def 			A_      (	__a     :				str = "The quick brown fox jumps over the lazy dog" ,		):

				"""simple docstring"""
				a__				      =		set()

				# Replace all the whitespace in our sentence
				a__				      =		input_str.replace(""" """ ,		""""""		)
				for alpha in input_str:
								if "a" <= alpha.lower() <= "z":
												frequency.add(alpha.lower()		)
				return len(__a		) == 26

def 			A_      (	__a     :				str = "The quick brown fox jumps over the lazy dog" ,		):

				"""simple docstring"""
				a__				      =		[False] * 26
				for char in input_str:
								if char.islower():
												a__				      =		True
								elif char.isupper():
												a__				      =		True
				return all(__a		)

def 			A_      (	__a     :				str = "The quick brown fox jumps over the lazy dog" ,		):

				"""simple docstring"""
				return len({char for char in input_str.lower() if char.isalpha()}		) == 26

def 			A_      (	):

				"""simple docstring"""
				from timeit import timeit

				a__				      =		"""from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest"""
				print(timeit("""is_pangram()""" ,		setup=__a		)		)
				print(timeit("""is_pangram_faster()""" ,		setup=__a		)		)
				print(timeit("""is_pangram_fastest()""" ,		setup=__a		)		)
				# 5.348480500048026, 2.6477354579837993, 1.8470395830227062
				# 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	benchmark()

