
"""simple docstring"""





from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
    from PIL import Image

    from transformers import ConvNextImageProcessor


class A_			:




  '''simple docstring'''







  def __init__(	self       ,     lowercase_       ,     lowercase_=13       ,     lowercase_=32       ,     lowercase_=3       ,     lowercase_=4       ,     lowercase_=[10, 20, 30, 40]       ,     lowercase_=[2, 2, 3, 2]       ,     lowercase_=True       ,     lowercase_=True       ,     lowercase_=37       ,     lowercase_="gelu"       ,     lowercase_=10       ,     lowercase_=0.02       ,     lowercase_=3       ,     lowercase_=None       ,     ):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[int]      =					parent
     UpperCAmelCase_      :      Union[str, Any]      =					batch_size
     UpperCAmelCase_      :      Union[str, Any]      =					image_size
     UpperCAmelCase_      :      Tuple      =					num_channels
     UpperCAmelCase_      :      Optional[Any]      =					num_stages
     UpperCAmelCase_      :      Union[str, Any]      =					hidden_sizes
     UpperCAmelCase_      :      List[str]      =					depths
     UpperCAmelCase_      :      str      =					is_training
     UpperCAmelCase_      :      Dict      =					use_labels
     UpperCAmelCase_      :      Any      =					intermediate_size
     UpperCAmelCase_      :      Tuple      =					hidden_act
     UpperCAmelCase_      :      int      =					type_sequence_label_size
     UpperCAmelCase_      :      Any      =					initializer_range
     UpperCAmelCase_      :      List[Any]      =					scope







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Any      =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

     UpperCAmelCase_      :      Optional[Any]      =					None
     if self.use_labels:
        UpperCAmelCase_      :      List[Any]      =					ids_tensor([self.batch_size]       ,     self.type_sequence_label_size						)

     UpperCAmelCase_      :      List[Any]      =					self.get_config()

     return config, pixel_values, labels







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     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=lowercase_       ,     initializer_range=self.initializer_range       ,     )







  def  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_       ,     lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      Any      =					TFConvNextModel(config=lowercase_						)
     UpperCAmelCase_      :      int      =					model(lowercase_       ,     training=lowercase_						)
     # 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  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_       ,     lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[Any]      =					self.type_sequence_label_size
     UpperCAmelCase_      :      Any      =					TFConvNextForImageClassification(lowercase_						)
     UpperCAmelCase_      :      List[Any]      =					model(lowercase_       ,     labels=lowercase_       ,     training=lowercase_						)
     self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Union[str, Any]      =					self.prepare_config_and_inputs()
     UpperCAmelCase_      :      Union[str, Any]      =					config_and_inputs
     UpperCAmelCase_      :      Dict      =					{"pixel_values": pixel_values}
     return config, inputs_dict




@require_tf
class A_			(lowercase__       ,lowercase__       ,unittest.TestCase   ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__    :		Tuple						  =	(TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
  SCREAMING_SNAKE_CASE__    :		str						  =	(
      {"""feature-extraction""": TFConvNextModel, """image-classification""": TFConvNextForImageClassification}
      if is_tf_available()
      else {}
  )

  SCREAMING_SNAKE_CASE__    :		int						  =	False
  SCREAMING_SNAKE_CASE__    :		List[Any]						  =	False
  SCREAMING_SNAKE_CASE__    :		Tuple						  =	False
  SCREAMING_SNAKE_CASE__    :		Optional[Any]						  =	False
  SCREAMING_SNAKE_CASE__    :		int						  =	False







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      List[Any]      =					TFConvNextModelTester(self						)
     UpperCAmelCase_      :      Union[str, Any]      =					ConfigTester(
         self       ,     config_class=lowercase_       ,     has_text_modality=lowercase_       ,     hidden_size=37       ,     )







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

     """simple docstring"""
     pass







  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices("GPU"						)						) == 0       ,     reason="TF does not support backprop for grouped convolutions on CPU."       ,     )
  @slow
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     super().test_keras_fit()







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

     """simple docstring"""
     pass







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        UpperCAmelCase_      :      Dict      =					model_class(lowercase_						)
        UpperCAmelCase_      :      str      =					inspect.signature(model.call						)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        UpperCAmelCase_      :      List[Any]      =					[*signature.parameters.keys()]

        UpperCAmelCase_      :      str      =					["pixel_values"]
        self.assertListEqual(arg_names[:1]       ,     lowercase_						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Union[str, Any]      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_						)







  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices("GPU"						)						) == 0       ,     reason="TF does not support backprop for grouped convolutions on CPU."       ,     )
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     super().test_dataset_conversion()







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     def check_hidden_states_output(lowercase_       ,     lowercase_       ,     lowercase_						):
        UpperCAmelCase_      :      Union[str, Any]      =					model_class(lowercase_						)

        UpperCAmelCase_      :      Tuple      =					model(**self._prepare_for_class(lowercase_       ,     lowercase_						)						)
        UpperCAmelCase_      :      Optional[int]      =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        UpperCAmelCase_      :      Tuple      =					self.model_tester.num_stages
        self.assertEqual(len(lowercase_						)       ,     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]       ,     )

     UpperCAmelCase_      :      List[Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        UpperCAmelCase_      :      List[str]      =					True
        check_hidden_states_output(lowercase_       ,     lowercase_       ,     lowercase_						)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        UpperCAmelCase_      :      Any      =					True

        check_hidden_states_output(lowercase_       ,     lowercase_       ,     lowercase_						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      int      =					self.model_tester.prepare_config_and_inputs_for_common()

     def check_equivalence(lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_={}						):
        UpperCAmelCase_      :      List[str]      =					model(lowercase_       ,     return_dict=lowercase_       ,     **lowercase_						)
        UpperCAmelCase_      :      Dict      =					model(lowercase_       ,     return_dict=lowercase_       ,     **lowercase_						).to_tuple()

        def recursive_check(lowercase_       ,     lowercase_						):
           if isinstance(lowercase_       ,     (List, Tuple)						):
              for tuple_iterable_value, dict_iterable_value in zip(lowercase_       ,     lowercase_						):
                 recursive_check(lowercase_       ,     lowercase_						)
           elif tuple_object is None:
              return
           else:
              self.assertTrue(
                  all(tf.equal(lowercase_       ,     lowercase_						)						)       ,     msg=(
                      "Tuple and dict output are not equal. Difference:"
                      F""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object						)						)}"""
                  )       ,     )

           recursive_check(lowercase_       ,     lowercase_						)

     for model_class in self.all_model_classes:
        UpperCAmelCase_      :      int      =					model_class(lowercase_						)

        UpperCAmelCase_      :      int      =					self._prepare_for_class(lowercase_       ,     lowercase_						)
        UpperCAmelCase_      :      Tuple      =					self._prepare_for_class(lowercase_       ,     lowercase_						)
        check_equivalence(lowercase_       ,     lowercase_       ,     lowercase_						)

        UpperCAmelCase_      :      List[str]      =					self._prepare_for_class(lowercase_       ,     lowercase_       ,     return_labels=lowercase_						)
        UpperCAmelCase_      :      List[Any]      =					self._prepare_for_class(lowercase_       ,     lowercase_       ,     return_labels=lowercase_						)
        check_equivalence(lowercase_       ,     lowercase_       ,     lowercase_						)

        UpperCAmelCase_      :      List[Any]      =					self._prepare_for_class(lowercase_       ,     lowercase_						)
        UpperCAmelCase_      :      int      =					self._prepare_for_class(lowercase_       ,     lowercase_						)
        check_equivalence(lowercase_       ,     lowercase_       ,     lowercase_       ,     {"output_hidden_states": True}						)

        UpperCAmelCase_      :      int      =					self._prepare_for_class(lowercase_       ,     lowercase_       ,     return_labels=lowercase_						)
        UpperCAmelCase_      :      Optional[int]      =					self._prepare_for_class(lowercase_       ,     lowercase_       ,     return_labels=lowercase_						)
        check_equivalence(lowercase_       ,     lowercase_       ,     lowercase_       ,     {"output_hidden_states": True}						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      str      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*lowercase_						)







  @slow
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Tuple      =					TFConvNextModel.from_pretrained("facebook/convnext-tiny-224"						)
     self.assertIsNotNone(lowercase_						)







def 			__a  (	):
   UpperCAmelCase_      :      str      =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
   return image


@require_tf
@require_vision
class A_			(unittest.TestCase   ):




  '''simple docstring'''







  @cached_property
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     return ConvNextImageProcessor.from_pretrained("facebook/convnext-tiny-224"						) if is_vision_available() else None







  @slow
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[Any]      =					TFConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"						)

     UpperCAmelCase_      :      str      =					self.default_image_processor
     UpperCAmelCase_      :      int      =					prepare_img()
     UpperCAmelCase_      :      str      =					image_processor(images=lowercase_       ,     return_tensors="tf"						)

     # forward pass
     UpperCAmelCase_      :      int      =					model(**lowercase_						)

     # verify the logits
     UpperCAmelCase_      :      Optional[int]      =					tf.TensorShape((1, 1000)						)
     self.assertEqual(outputs.logits.shape       ,     lowercase_						)

     UpperCAmelCase_      :      Union[str, Any]      =					tf.constant([-0.02_60, -0.47_39, 0.19_11]						)

     tf.debugging.assert_near(outputs.logits[0, :3]       ,     lowercase_       ,     atol=1E-4						)




"""simple docstring"""





from __future__ import annotations

from typing import Any


class A_			:




  '''simple docstring'''







  def __init__(	self       ,     lowercase_       ,     lowercase_						):  # noqa: A002

     """simple docstring"""
     UpperCAmelCase_      :      Optional[Any]      =					item
     UpperCAmelCase_      :      Optional[Any]      =					next




class A_			:




  '''simple docstring'''







  def __init__(	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Node | None      =					None
     UpperCAmelCase_      :      Optional[int]      =					0







  def  UpperCamelCase__      (	self       ,     lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      int      =					Node(lowercase_       ,     self.head						)
     self.size += 1







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     # Switched 'self.is_empty()' to 'self.head is None'
     # because mypy was considering the possibility that 'self.head'
     # can be None in below else part and giving error
     if self.head is None:
        return None
     else:
        UpperCAmelCase_      :      int      =					self.head.item
        UpperCAmelCase_      :      str      =					self.head.next
        self.size -= 1
        return item







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     return self.head is None







  def __str__(	self						):

     """simple docstring"""
     if self.is_empty():
        return ""
     else:
        UpperCAmelCase_      :      str      =					self.head
        UpperCAmelCase_      :      str      =					""
        UpperCAmelCase_      :      list[str]      =					[]
        while iterate:
           item_list.append(str(iterate.item						)						)
           UpperCAmelCase_      :      Tuple      =					iterate.next

        UpperCAmelCase_      :      Optional[Any]      =					" --> ".join(lowercase_						)

        return item_str







  def __len__(	self						):

     """simple docstring"""
     return self.size


