






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 							lowerCamelCase__ (       __lowerCamelCase     :	List[str]						):
  __UpperCAmelCase				:      Any	 =    []
  for line in lines:
    __UpperCAmelCase				:      Optional[int]	 =    re.sub(R"""#.*"""    ,						""""""    ,						__lowerCamelCase						)  # remove comments
    if line:
      filtered_lines.append(__lowerCamelCase						)
  __UpperCAmelCase				:      Any	 =    """\n""".join(__lowerCamelCase						)

  # Make a hash from all this code
  __UpperCAmelCase				:      int	 =    full_str.encode("""utf-8"""						)
  return shaaaa(__lowerCamelCase						).hexdigest()


# get importable module names and hash for caching
a						:			Union[str, Any]     	=					{
    "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						:			str     	=					{
    ".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						:			Any     	=					{"imagefolder", "audiofolder"}

# Used to filter data files based on extensions given a module name
a						:			Dict[str, List[str]]     	=					{}
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")




"""simple docstring"""




import inspect
import unittest

from huggingface_hub import hf_hub_download

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import UperNetForSemanticSegmentation
  from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor


class       __magic_name__							:
       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_=3			,					A_=None			,					)  ->						List[str]:





         """simple docstring"""




         _lowercase:      str   			=  parent
         _lowercase:      Union[str, Any]   			=  batch_size
         _lowercase:      Tuple   			=  image_size
         _lowercase:      Tuple   			=  num_channels
         _lowercase:      Optional[int]   			=  num_stages
         _lowercase:      List[Any]   			=  hidden_sizes
         _lowercase:      Dict   			=  depths
         _lowercase:      int   			=  is_training
         _lowercase:      Tuple   			=  use_labels
         _lowercase:      Any   			=  intermediate_size
         _lowercase:      Union[str, Any]   			=  hidden_act
         _lowercase:      str   			=  type_sequence_label_size
         _lowercase:      int   			=  initializer_range
         _lowercase:      List[str]   			=  out_features
         _lowercase:      Any   			=  num_labels
         _lowercase:      Any   			=  scope
         _lowercase:      str   			=  num_stages
       def 				lowercase_				(  self							)  ->						str:





         """simple docstring"""




         _lowercase:      Union[str, Any]   			=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

         _lowercase:      Any   			=  None
         if self.use_labels:
           _lowercase:      Dict   			=  ids_tensor([self.batch_size]			,					self.type_sequence_label_size							)

         _lowercase:      Tuple   			=  self.get_config()

         return config, pixel_values, labels
       def 				lowercase_				(  self							)  ->						List[Any]:





         """simple docstring"""




         return ConvNextConfig(
             num_channels=self.num_channels			,					num_stages=self.num_stages			,					hidden_sizes=self.hidden_sizes			,					depths=self.depths			,					is_training=self.is_training			,					intermediate_size=self.intermediate_size			,					hidden_act=self.hidden_act			,					out_features=self.out_features			,					)
       def 				lowercase_				(  self							)  ->						Dict:





         """simple docstring"""




         return UperNetConfig(
             backbone_config=self.get_backbone_config()			,					hidden_size=512			,					pool_scales=[1, 2, 3, 6]			,					use_auxiliary_head=A_			,					auxiliary_loss_weight=0.4			,					auxiliary_in_channels=40			,					auxiliary_channels=256			,					auxiliary_num_convs=1			,					auxiliary_concat_input=A_			,					loss_ignore_index=255			,					num_labels=self.num_labels			,					)
       def 				lowercase_				(  self			,					A_			,					A_			,					A_							)  ->						int:





         """simple docstring"""




         _lowercase:      List[str]   			=  UperNetForSemanticSegmentation(config=A_							)
         model.to(A_							)
         model.eval()
         _lowercase:      int   			=  model(A_							)
         self.parent.assertEqual(
             result.logits.shape			,					(self.batch_size, self.num_labels, self.image_size, self.image_size)							)



       def 				lowercase_				(  self							)  ->						List[str]:





         """simple docstring"""




         _lowercase:      Optional[int]   			=  self.prepare_config_and_inputs()
         (
             (
             _lowercase
         )			,					(
             _lowercase
         )			,					(
             _lowercase
         )			,					
         ):      Tuple   			=  config_and_inputs
         _lowercase:      str   			=  {'''pixel_values''': pixel_values}
         return config, inputs_dict


@require_torch
class       __magic_name__							(							SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__ ,       unittest.TestCase			):
       UpperCamelCase_ =		(UperNetForSemanticSegmentation,) if is_torch_available() else ()
       UpperCamelCase_ =		{'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       def 				lowercase_				(  self							)  ->						Optional[int]:





         """simple docstring"""




         _lowercase:      List[Any]   			=  UperNetModelTester(self							)
         _lowercase:      Optional[Any]   			=  ConfigTester(self			,					config_class=A_			,					has_text_modality=A_			,					hidden_size=37							)
       def 				lowercase_				(  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 				lowercase_				(  self							)  ->						Dict:





         """simple docstring"""




         return
       def 				lowercase_				(  self							)  ->						Dict:





         """simple docstring"""




         _lowercase			,					_lowercase:      Union[str, Any]   			=  self.model_tester.prepare_config_and_inputs_for_common()

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

           _lowercase:      int   			=  ['''pixel_values''']
           self.assertListEqual(arg_names[:1]			,					A_							)
       def 				lowercase_				(  self							)  ->						Tuple:





         """simple docstring"""




         _lowercase:      List[str]   			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*A_							)
       @unittest.skip(reason='''UperNet does not use inputs_embeds'''							)
       def 				lowercase_				(  self							)  ->						str:





         """simple docstring"""




         pass
       @unittest.skip(reason='''UperNet does not support input and output embeddings'''							)
       def 				lowercase_				(  self							)  ->						List[Any]:





         """simple docstring"""




         pass
       @unittest.skip(reason='''UperNet does not have a base model'''							)
       def 				lowercase_				(  self							)  ->						Tuple:





         """simple docstring"""




         pass
       @unittest.skip(reason='''UperNet does not have a base model'''							)
       def 				lowercase_				(  self							)  ->						Tuple:





         """simple docstring"""




         pass
       @require_torch_multi_gpu
       @unittest.skip(reason='''UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''							)
       def 				lowercase_				(  self							)  ->						Optional[Any]:





         """simple docstring"""




         pass
       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''							)
       def 				lowercase_				(  self							)  ->						List[Any]:





         """simple docstring"""




         pass
       def 				lowercase_				(  self							)  ->						str:





         """simple docstring"""




         def check_hidden_states_output(A_			,					A_			,					A_							):
           _lowercase:      Dict   			=  model_class(A_							)
           model.to(A_							)
           model.eval()

           with torch.no_grad():
             _lowercase:      List[str]   			=  model(**self._prepare_for_class(A_			,					A_							)							)

           _lowercase:      Tuple   			=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

           _lowercase:      Union[str, Any]   			=  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]			,					)

         _lowercase			,					_lowercase:      Dict   			=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           _lowercase:      Optional[int]   			=  True
           check_hidden_states_output(A_			,					A_			,					A_							)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _lowercase:      Union[str, Any]   			=  True

           check_hidden_states_output(A_			,					A_			,					A_							)
       def 				lowercase_				(  self							)  ->						Union[str, Any]:





         """simple docstring"""




         _lowercase			,					_lowercase:      Any   			=  self.model_tester.prepare_config_and_inputs_for_common()

         _lowercase:      int   			=  _config_zero_init(A_							)
         _lowercase:      Optional[Any]   			=  _config_zero_init(configs_no_init.backbone_config							)
         for model_class in self.all_model_classes:
           _lowercase:      Any   			=  model_class(config=A_							)
           for name, param in model.named_parameters():
             if param.requires_grad:
               self.assertIn(
                   ((param.data.mean() * 1E9).round() / 1E9).item()			,					[0.0, 1.0]			,					msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''			,					)
       @unittest.skip(reason='''UperNet does not have tied weights'''							)
       def 				lowercase_				(  self							)  ->						List[str]:





         """simple docstring"""




         pass



       @slow
       def 				lowercase_				(  self							)  ->						Tuple:





         """simple docstring"""




         for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowercase:      Union[str, Any]   			=  UperNetForSemanticSegmentation.from_pretrained(A_							)
           self.assertIsNotNone(A_							)




def 			_lowerCAmelCase		(		):






  """simple docstring"""



  _lowercase:      List[str]   			=  hf_hub_download(
      repo_id='''hf-internal-testing/fixtures_ade20k'''			,					repo_type='''dataset'''			,					filename='''ADE_val_00000001.jpg'''    )
  _lowercase:      Optional[int]   			=  Image.open(_UpperCamelCase    ).convert('''RGB'''    )
  return image







@require_torch
@require_vision
@slow
class       __magic_name__							(							unittest.TestCase			):
       def 				lowercase_				(  self							)  ->						int:





         """simple docstring"""




         _lowercase:      Optional[Any]   			=  AutoImageProcessor.from_pretrained('''openmmlab/upernet-swin-tiny'''							)
         _lowercase:      Optional[Any]   			=  UperNetForSemanticSegmentation.from_pretrained('''openmmlab/upernet-swin-tiny'''							).to(A_							)

         _lowercase:      List[Any]   			=  prepare_img()
         _lowercase:      Any   			=  processor(images=A_			,					return_tensors='''pt'''							).to(A_							)

         with torch.no_grad():
           _lowercase:      str   			=  model(**A_							)

         _lowercase:      Union[str, Any]   			=  torch.Size((1, model.config.num_labels, 512, 512)							)
         self.assertEqual(outputs.logits.shape			,					A_							)

         _lowercase:      Optional[Any]   			=  torch.tensor(
             [[-7.59_58, -7.59_58, -7.43_02], [-7.59_58, -7.59_58, -7.43_02], [-7.47_97, -7.47_97, -7.30_68]]							).to(A_							)
         self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]			,					A_			,					atol=1E-4							)							)



       def 				lowercase_				(  self							)  ->						int:





         """simple docstring"""




         _lowercase:      Tuple   			=  AutoImageProcessor.from_pretrained('''openmmlab/upernet-convnext-tiny'''							)
         _lowercase:      str   			=  UperNetForSemanticSegmentation.from_pretrained('''openmmlab/upernet-convnext-tiny'''							).to(A_							)

         _lowercase:      Union[str, Any]   			=  prepare_img()
         _lowercase:      Optional[Any]   			=  processor(images=A_			,					return_tensors='''pt'''							).to(A_							)

         with torch.no_grad():
           _lowercase:      str   			=  model(**A_							)

         _lowercase:      Optional[Any]   			=  torch.Size((1, model.config.num_labels, 512, 512)							)
         self.assertEqual(outputs.logits.shape			,					A_							)

         _lowercase:      Tuple   			=  torch.tensor(
             [[-8.81_10, -8.81_10, -8.65_21], [-8.81_10, -8.81_10, -8.65_21], [-8.77_46, -8.77_46, -8.61_30]]							).to(A_							)
         self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]			,					A_			,					atol=1E-4							)							)
