



'''simple docstring'''





import inspect
import re
from hashlib import shaaaa
from typing import Dict, List

from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql  # noqa F401
from .text import text





def 						__snake_case(				_lowerCAmelCase		)		-> str:
      snake_case__  :    str    						=      []
      for line in lines:
            snake_case__  :    Tuple    						=      re.sub(r"""#.*"""     ,   """"""     ,   _lowerCAmelCase		)  # remove comments
            if line:
                  filtered_lines.append(_lowerCAmelCase		)
      snake_case__  :    Optional[Any]    						=      """\n""".join(_lowerCAmelCase		)

      # Make a hash from all this code
      snake_case__  :    str    						=      full_str.encode("""utf-8"""		)
      return shaaaa(_lowerCAmelCase		).hexdigest()


# get importable module names and hash for caching
__a          =		{
    "csv": (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
    "json": (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
    "pandas": (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
    "parquet": (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
    "arrow": (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
    "text": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
    "imagefolder": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
    "audiofolder": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}

# Used to infer the module to use based on the data files extensions
__a          =		{
    ".csv": ("csv", {}),
    ".tsv": ("csv", {"sep": "\t"}),
    ".json": ("json", {}),
    ".jsonl": ("json", {}),
    ".parquet": ("parquet", {}),
    ".arrow": ("arrow", {}),
    ".txt": ("text", {}),
}
_EXTENSION_TO_MODULE.update({ext: ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
__a          =		{"imagefolder", "audiofolder"}

# Used to filter data files based on extensions given a module name
__a          =		{}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
       _MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)

_MODULE_TO_EXTENSIONS["imagefolder"].append(".zip")



_MODULE_TO_EXTENSIONS["audiofolder"].append(".zip")





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 				lowerCAmelCase_		:
       def __init__(			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_=13,			SCREAMING_SNAKE_CASE_=32,			SCREAMING_SNAKE_CASE_=3,			SCREAMING_SNAKE_CASE_=4,			SCREAMING_SNAKE_CASE_=[10, 20, 30, 40],			SCREAMING_SNAKE_CASE_=[2, 2, 3, 2],			SCREAMING_SNAKE_CASE_=True,			SCREAMING_SNAKE_CASE_=True,			SCREAMING_SNAKE_CASE_=37,			SCREAMING_SNAKE_CASE_="gelu",			SCREAMING_SNAKE_CASE_=10,			SCREAMING_SNAKE_CASE_=0.02,			SCREAMING_SNAKE_CASE_=["stage2", "stage3", "stage4"],			SCREAMING_SNAKE_CASE_=[2, 3, 4],			SCREAMING_SNAKE_CASE_=None,			)     ->		Optional[int]:
          UpperCamelCase    :  Dict							=	parent
          UpperCamelCase    :  Optional[Any]							=	batch_size
          UpperCamelCase    :  Union[str, Any]							=	image_size
          UpperCamelCase    :  Union[str, Any]							=	num_channels
          UpperCamelCase    :  List[Any]							=	num_stages
          UpperCamelCase    :  Any							=	hidden_sizes
          UpperCamelCase    :  Optional[int]							=	depths
          UpperCamelCase    :  Optional[int]							=	is_training
          UpperCamelCase    :  List[str]							=	use_labels
          UpperCamelCase    :  Dict							=	intermediate_size
          UpperCamelCase    :  List[Any]							=	hidden_act
          UpperCamelCase    :  Union[str, Any]							=	num_labels
          UpperCamelCase    :  str							=	initializer_range
          UpperCamelCase    :  List[str]							=	out_features
          UpperCamelCase    :  List[str]							=	out_indices
          UpperCamelCase    :  str							=	scope
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          UpperCamelCase    :  int							=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

          UpperCamelCase    :  List[Any]							=	self.get_config()
          return config, pixel_values, labels
       def 					snake_case_       (			self       )     ->		Any:
          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=SCREAMING_SNAKE_CASE_,			initializer_range=self.initializer_range,			out_features=self.out_features,			out_indices=self.out_indices,			num_labels=self.num_labels,			)
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Tuple:
          UpperCamelCase    :  Dict							=	ConvNextModel(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  str							=	model(SCREAMING_SNAKE_CASE_       )
          # 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 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Optional[Any]:
          UpperCamelCase    :  Optional[int]							=	ConvNextForImageClassification(SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Dict							=	model(SCREAMING_SNAKE_CASE_,			labels=SCREAMING_SNAKE_CASE_       )
          self.parent.assertEqual(result.logits.shape,			(self.batch_size, self.num_labels)       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Dict:
          UpperCamelCase    :  int							=	ConvNextBackbone(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Any							=	model(SCREAMING_SNAKE_CASE_       )

          # 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
          UpperCamelCase    :  Any							=	None
          UpperCamelCase    :  List[str]							=	ConvNextBackbone(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Tuple							=	model(SCREAMING_SNAKE_CASE_       )

          # 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 					snake_case_       (			self       )     ->		int:
          UpperCamelCase    :  Optional[int]							=	self.prepare_config_and_inputs()
          UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  Optional[Any]							=	config_and_inputs
          UpperCamelCase    :  str							=	{'pixel_values': pixel_values}
          return config, inputs_dict






@require_torch
class 				lowerCAmelCase_		(  a__       ,    a__       ,    unittest.TestCase							):
       UpperCAmelCase__				:					List[Any]        =  (
           (
               ConvNextModel,
               ConvNextForImageClassification,
               ConvNextBackbone,
           )
           if is_torch_available()
           else ()
       )
       UpperCAmelCase__				:					Union[str, Any]        =  (
           {"feature-extraction": ConvNextModel, "image-classification": ConvNextForImageClassification}
           if is_torch_available()
           else {}
       )

       UpperCAmelCase__				:					Dict        =  True
       UpperCAmelCase__				:					List[str]        =  False
       UpperCAmelCase__				:					Tuple        =  False
       UpperCAmelCase__				:					List[Any]        =  False
       UpperCAmelCase__				:					Tuple        =  False
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          UpperCamelCase    :  Dict							=	ConvNextModelTester(self       )
          UpperCamelCase    :  int							=	ConfigTester(self,			config_class=SCREAMING_SNAKE_CASE_,			has_text_modality=SCREAMING_SNAKE_CASE_,			hidden_size=37       )
       def 					snake_case_       (			self       )     ->		List[str]:
          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 					snake_case_       (			self       )     ->		Union[str, Any]:
          return
       @unittest.skip(reason='ConvNext does not use inputs_embeds'       )
       def 					snake_case_       (			self       )     ->		List[str]:
          pass
       @unittest.skip(reason='ConvNext does not support input and output embeddings'       )
       def 					snake_case_       (			self       )     ->		str:
          pass
       @unittest.skip(reason='ConvNext does not use feedforward chunking'       )
       def 					snake_case_       (			self       )     ->		str:
          pass
       def 					snake_case_       (			self       )     ->		Any:
          UpperCamelCase	,     UpperCamelCase    :  Optional[int]							=	self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCamelCase    :  Union[str, Any]							=	['pixel_values']
             self.assertListEqual(arg_names[:1],			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		List[str]:
          UpperCamelCase    :  Optional[int]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Dict:
          UpperCamelCase    :  Optional[Any]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Dict:
          def check_hidden_states_output(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
             UpperCamelCase    :  List[Any]							=	model_class(SCREAMING_SNAKE_CASE_       )
             model.to(SCREAMING_SNAKE_CASE_       )
             model.eval()

             with torch.no_grad():
                UpperCamelCase    :  List[Any]							=	model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )       )

             UpperCamelCase    :  List[str]							=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             UpperCamelCase    :  int							=	self.model_tester.num_stages
             self.assertEqual(len(SCREAMING_SNAKE_CASE_       ),			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	,     UpperCamelCase    :  Tuple							=	self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             UpperCamelCase    :  Optional[int]							=	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"]
             UpperCamelCase    :  str							=	True

             check_hidden_states_output(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		List[str]:
          UpperCamelCase    :  List[Any]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_       )






       @slow
       def 					snake_case_       (			self       )     ->		Tuple:
          for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase    :  Union[str, Any]							=	ConvNextModel.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )






def 		UpperCamelCase	(   )	->     int:
   UpperCamelCase    :  Optional[int]							=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
   return image



@require_torch
@require_vision
class 				lowerCAmelCase_		(  unittest.TestCase							):
       @cached_property
       def 					snake_case_       (			self       )     ->		Optional[int]:
          return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224'       ) if is_vision_available() else None






       @slow
       def 					snake_case_       (			self       )     ->		str:
          UpperCamelCase    :  Dict							=	ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224'       ).to(SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  Union[str, Any]							=	self.default_image_processor
          UpperCamelCase    :  Any							=	prepare_img()
          UpperCamelCase    :  List[str]							=	image_processor(images=SCREAMING_SNAKE_CASE_,			return_tensors='pt'       ).to(SCREAMING_SNAKE_CASE_       )

          # forward pass
          with torch.no_grad():
             UpperCamelCase    :  Optional[Any]							=	model(**SCREAMING_SNAKE_CASE_       )

          # verify the logits
          UpperCamelCase    :  List[Any]							=	torch.Size((1, 1000)       )
          self.assertEqual(outputs.logits.shape,			SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  List[str]							=	torch.tensor([-0.02_60, -0.47_39, 0.19_11]       ).to(SCREAMING_SNAKE_CASE_       )

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






@require_torch
class 				lowerCAmelCase_		(  unittest.TestCase       ,    a__							):
       UpperCAmelCase__				:					Tuple        =  (ConvNextBackbone,) if is_torch_available() else ()
       UpperCAmelCase__				:					List[str]        =  ConvNextConfig

       UpperCAmelCase__				:					Tuple        =  False
       def 					snake_case_       (			self       )     ->		int:
          UpperCamelCase    :  List[Any]							=	ConvNextModelTester(self       )



