






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

  '''simple docstring'''







  def __init__(      self		:			List[Any]       ,				lowerCamelCase		:			Tuple       ,				lowerCamelCase		:			Optional[Any]=13       ,				lowerCamelCase		:			Any=32       ,				lowerCamelCase		:			List[str]=3       ,				lowerCamelCase		:			Any=4       ,				lowerCamelCase		:			Tuple=[10, 20, 30, 40]       ,				lowerCamelCase		:			Dict=[2, 2, 3, 2]       ,				lowerCamelCase		:			List[Any]=True       ,				lowerCamelCase		:			List[Any]=True       ,				lowerCamelCase		:			Dict=37       ,				lowerCamelCase		:			Optional[Any]="gelu"       ,				lowerCamelCase		:			List[Any]=10       ,				lowerCamelCase		:			Any=0.02       ,				lowerCamelCase		:			Dict=["stage2", "stage3", "stage4"]       ,				lowerCamelCase		:			str=3       ,				lowerCamelCase		:			str=None       ,				)						->	List[str]:


         """simple docstring"""
         _UpperCAmelCase							=    parent
         _UpperCAmelCase							=    batch_size
         _UpperCAmelCase							=    image_size
         _UpperCAmelCase							=    num_channels
         _UpperCAmelCase							=    num_stages
         _UpperCAmelCase							=    hidden_sizes
         _UpperCAmelCase							=    depths
         _UpperCAmelCase							=    is_training
         _UpperCAmelCase							=    use_labels
         _UpperCAmelCase							=    intermediate_size
         _UpperCAmelCase							=    hidden_act
         _UpperCAmelCase							=    type_sequence_label_size
         _UpperCAmelCase							=    initializer_range
         _UpperCAmelCase							=    out_features
         _UpperCAmelCase							=    num_labels
         _UpperCAmelCase							=    scope
         _UpperCAmelCase							=    num_stages


  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	int:


         """simple docstring"""
         _UpperCAmelCase							=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

         _UpperCAmelCase							=    None
         if self.use_labels:
                _UpperCAmelCase							=    ids_tensor([self.batch_size]       ,				self.type_sequence_label_size							)

         _UpperCAmelCase							=    self.get_config()

         return config, pixel_values, labels


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	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  lowerCamelCase       (      self		:			Optional[int]							)						->	List[str]:


         """simple docstring"""
         return UperNetConfig(
             backbone_config=self.get_backbone_config()       ,				hidden_size=512       ,				pool_scales=[1, 2, 3, 6]       ,				use_auxiliary_head=lowerCamelCase       ,				auxiliary_loss_weight=0.4       ,				auxiliary_in_channels=40       ,				auxiliary_channels=256       ,				auxiliary_num_convs=1       ,				auxiliary_concat_input=lowerCamelCase       ,				loss_ignore_index=255       ,				num_labels=self.num_labels       ,				)


  def  lowerCamelCase       (      self		:			Any       ,				lowerCamelCase		:			Any       ,				lowerCamelCase		:			List[Any]       ,				lowerCamelCase		:			Dict							)						->	Tuple:


         """simple docstring"""
         _UpperCAmelCase							=    UperNetForSemanticSegmentation(config=lowerCamelCase							)
         model.to(lowerCamelCase							)
         model.eval()
         _UpperCAmelCase							=    model(lowerCamelCase							)
         self.parent.assertEqual(
             result.logits.shape       ,				(self.batch_size, self.num_labels, self.image_size, self.image_size)							)





  def  lowerCamelCase       (      self		:			List[Any]							)						->	int:


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



@require_torch
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase					,      UpperCAmelCase					,      unittest.TestCase     ):

  '''simple docstring'''







  _lowerCamelCase    =  (UperNetForSemanticSegmentation,) if is_torch_available() else ()
  _lowerCamelCase    =  {'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False
  _lowerCamelCase    =  False


  def  lowerCamelCase       (      self		:			Tuple							)						->	Tuple:


         """simple docstring"""
         _UpperCAmelCase							=    UperNetModelTester(self							)
         _UpperCAmelCase							=    ConfigTester(self       ,				config_class=lowerCamelCase       ,				has_text_modality=lowerCamelCase       ,				hidden_size=37							)


  def  lowerCamelCase       (      self		:			Any							)						->	int:


         """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  lowerCamelCase       (      self		:			Tuple							)						->	Any:


         """simple docstring"""
         return


  def  lowerCamelCase       (      self		:			Any							)						->	Optional[int]:


         """simple docstring"""
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs_for_common()

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

                _UpperCAmelCase							=    ["""pixel_values"""]
                self.assertListEqual(arg_names[:1]       ,				lowerCamelCase							)


  def  lowerCamelCase       (      self		:			int							)						->	str:


         """simple docstring"""
         _UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase							)


  @unittest.skip(reason="""UperNet does not use inputs_embeds"""							)
  def  lowerCamelCase       (      self		:			List[Any]							)						->	Optional[int]:


         """simple docstring"""
         pass


  @unittest.skip(reason="""UperNet does not support input and output embeddings"""							)
  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	Union[str, Any]:


         """simple docstring"""
         pass


  @unittest.skip(reason="""UperNet does not have a base model"""							)
  def  lowerCamelCase       (      self		:			Optional[int]							)						->	Tuple:


         """simple docstring"""
         pass


  @unittest.skip(reason="""UperNet does not have a base model"""							)
  def  lowerCamelCase       (      self		:			Dict							)						->	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  lowerCamelCase       (      self		:			str							)						->	Tuple:


         """simple docstring"""
         pass


  @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""							)
  def  lowerCamelCase       (      self		:			str							)						->	Dict:


         """simple docstring"""
         pass


  def  lowerCamelCase       (      self		:			List[Any]							)						->	List[str]:


         """simple docstring"""
         def check_hidden_states_output(lowerCamelCase		:			Optional[int]       ,				lowerCamelCase		:			Union[str, Any]       ,				lowerCamelCase		:			str							):
                _UpperCAmelCase							=    model_class(lowerCamelCase							)
                model.to(lowerCamelCase							)
                model.eval()

                with torch.no_grad():
                       _UpperCAmelCase							=    model(**self._prepare_for_class(lowerCamelCase       ,				lowerCamelCase							)							)

                _UpperCAmelCase							=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                _UpperCAmelCase							=    self.model_tester.num_stages
                self.assertEqual(len(lowerCamelCase							)       ,				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							=    self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                _UpperCAmelCase							=    True
                check_hidden_states_output(lowerCamelCase       ,				lowerCamelCase       ,				lowerCamelCase							)

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

                check_hidden_states_output(lowerCamelCase       ,				lowerCamelCase       ,				lowerCamelCase							)


  def  lowerCamelCase       (      self		:			Any							)						->	Dict:


         """simple docstring"""
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.model_tester.prepare_config_and_inputs_for_common()

         _UpperCAmelCase							=    _config_zero_init(lowerCamelCase							)
         _UpperCAmelCase							=    _config_zero_init(configs_no_init.backbone_config							)
         for model_class in self.all_model_classes:
                _UpperCAmelCase							=    model_class(config=lowerCamelCase							)
                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  lowerCamelCase       (      self		:			Union[str, Any]							)						->	Tuple:


         """simple docstring"""
         pass





  @slow
  def  lowerCamelCase       (      self		:			str							)						->	Optional[int]:


         """simple docstring"""
         for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                _UpperCAmelCase							=    UperNetForSemanticSegmentation.from_pretrained(lowerCamelCase							)
                self.assertIsNotNone(lowerCamelCase							)




def       _SCREAMING_SNAKE_CASE (							)				->						Union[str, Any]:
       _UpperCAmelCase							=    hf_hub_download(
           repo_id="""hf-internal-testing/fixtures_ade20k"""   ,      repo_type="""dataset"""   ,      filename="""ADE_val_00000001.jpg""" )
       _UpperCAmelCase							=    Image.open(__snake_case ).convert("""RGB""" )
       return image





@require_torch
@require_vision
@slow
class 		SCREAMING_SNAKE_CASE__	(  unittest.TestCase     ):

  '''simple docstring'''







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


         """simple docstring"""
         _UpperCAmelCase							=    AutoImageProcessor.from_pretrained("""openmmlab/upernet-swin-tiny"""							)
         _UpperCAmelCase							=    UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-swin-tiny"""							).to(lowerCamelCase							)

         _UpperCAmelCase							=    prepare_img()
         _UpperCAmelCase							=    processor(images=lowerCamelCase       ,				return_tensors="""pt"""							).to(lowerCamelCase							)

         with torch.no_grad():
                _UpperCAmelCase							=    model(**lowerCamelCase							)

         _UpperCAmelCase							=    torch.Size((1, model.config.num_labels, 512, 512)							)
         self.assertEqual(outputs.logits.shape       ,				lowerCamelCase							)

         _UpperCAmelCase							=    torch.tensor(
             [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]]							).to(lowerCamelCase							)
         self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]       ,				lowerCamelCase       ,				atol=1E-4							)							)





  def  lowerCamelCase       (      self		:			List[Any]							)						->	List[str]:


         """simple docstring"""
         _UpperCAmelCase							=    AutoImageProcessor.from_pretrained("""openmmlab/upernet-convnext-tiny"""							)
         _UpperCAmelCase							=    UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-convnext-tiny"""							).to(lowerCamelCase							)

         _UpperCAmelCase							=    prepare_img()
         _UpperCAmelCase							=    processor(images=lowerCamelCase       ,				return_tensors="""pt"""							).to(lowerCamelCase							)

         with torch.no_grad():
                _UpperCAmelCase							=    model(**lowerCamelCase							)

         _UpperCAmelCase							=    torch.Size((1, model.config.num_labels, 512, 512)							)
         self.assertEqual(outputs.logits.shape       ,				lowerCamelCase							)

         _UpperCAmelCase							=    torch.tensor(
             [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]]							).to(lowerCamelCase							)
         self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]       ,				lowerCamelCase       ,				atol=1E-4							)							)

"""simple docstring"""




# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


_A     :			List[str]  						=			get_logger(__name__)

class 						a__		:
   __lowerCAmelCase				=							"""dummy_data"""
   __lowerCAmelCase				=							"""datasets"""
   __lowerCAmelCase				=							False
   def __init__(     self      ,       _a      ,       _a      ,       _a      ,       _a = None      ,       _a = False      ,       _a = True      ,       _a = None      ,       ):
          lowercase       :							int									=				0
          lowercase       :							Optional[Any]									=				dataset_name
          lowercase       :							List[str]									=				cache_dir
          lowercase       :							Union[str, Any]									=				use_local_dummy_data
          lowercase       :							str									=				config
          # download_callbacks take a single url as input
          lowercase       :							List[Callable]									=				download_callbacks or []
          # if False, it doesn't load existing files and it returns the paths of the dummy files relative
          # to the dummy_data zip file root
          lowercase       :							List[Any]									=				load_existing_dummy_data

          # TODO(PVP, QL) might need to make this more general
          lowercase       :							Tuple									=				str(_a							)
          # to be downloaded
          lowercase       :							Tuple									=				None
          lowercase       :							List[Any]									=				None
   @property
   def      __magic_name__     (     self							):
          if self._dummy_file is None:
                 lowercase       :							Optional[int]									=				self.download_dummy_data()
          return self._dummy_file
   @property
   def      __magic_name__     (     self							):
          if self.config is not None:
                 # structure is dummy / config_name / version_name
                 return os.path.join("dummy"      ,       self.config.name      ,       self.version_name							)
          # structure is dummy / version_name
          return os.path.join("dummy"      ,       self.version_name							)
   @property
   def      __magic_name__     (     self							):
          return os.path.join(self.dummy_data_folder      ,       "dummy_data.zip"							)
   def      __magic_name__     (     self							):
          lowercase       :							Optional[Any]									=				(
              self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
          )

          lowercase       :							str									=				cached_path(
              _a      ,       cache_dir=self.cache_dir      ,       extract_compressed_file=_a      ,       force_extract=_a							)

          return os.path.join(_a      ,       self.dummy_file_name							)
   @property
   def      __magic_name__     (     self							):
          return os.path.join(self.datasets_scripts_dir      ,       self.dataset_name      ,       self.dummy_zip_file							)
   @property
   def      __magic_name__     (     self							):
          if self._bucket_url is None:
                 lowercase       :							Dict									=				hf_github_url(self.dataset_name      ,       self.dummy_zip_file.replace(os.sep      ,       "/"							)							)
          return self._bucket_url
   @property
   def      __magic_name__     (     self							):
          # return full path if its a dir
          if os.path.isdir(self.dummy_file							):
                 return self.dummy_file
          # else cut off path to file -> example `xsum`.
          return "/".join(self.dummy_file.replace(os.sep      ,       "/"							).split("/"							)[:-1]							)
   def      __magic_name__     (     self      ,       _a      ,       *_a							):
          if self.load_existing_dummy_data:
                 # dummy data is downloaded and tested
                 lowercase       :							Optional[int]									=				self.dummy_file
          else:
                 # dummy data cannot be downloaded and only the path to dummy file is returned
                 lowercase       :							Optional[Any]									=				self.dummy_file_name

          # special case when data_url is a dict
          if isinstance(_a      ,       _a							):
                 return self.create_dummy_data_dict(_a      ,       _a							)
          elif isinstance(_a      ,       (list, tuple)							):
                 return self.create_dummy_data_list(_a      ,       _a							)
          else:
                 return self.create_dummy_data_single(_a      ,       _a							)
   def      __magic_name__     (     self      ,       _a      ,       *_a							):
          return self.download_and_extract(_a							)
   def      __magic_name__     (     self      ,       _a      ,       _a							):
          return self.download_and_extract(_a							)
   def      __magic_name__     (     self      ,       _a      ,       *_a      ,       **_a							):
          return path
   def      __magic_name__     (     self							):
          return {}
   def      __magic_name__     (     self      ,       _a      ,       _a							):
          lowercase       :							List[str]									=				{}
          for key, single_urls in data_url.items():
                 for download_callback in self.download_callbacks:
                        if isinstance(_a      ,       _a							):
                               for single_url in single_urls:
                                      download_callback(_a							)
                        else:
                               lowercase       :							Union[str, Any]									=				single_urls
                               download_callback(_a							)
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
                 if isinstance(_a      ,       _a							):
                        lowercase       :							Any									=				[os.path.join(_a      ,       urllib.parse.quote_plus(Path(_a							).name							)							) for x in single_urls]
                 else:
                        lowercase       :							int									=				single_urls
                        lowercase       :							Tuple									=				os.path.join(_a      ,       urllib.parse.quote_plus(Path(_a							).name							)							)
                 lowercase       :							List[str]									=				value

          # make sure that values are unique
          if all(isinstance(_a      ,       _a							) for i in dummy_data_dict.values()							) and len(set(dummy_data_dict.values()							)							) < len(
              dummy_data_dict.values()							):
                 # append key to value to make its name unique
                 lowercase       :							str									=				{key: value + key for key, value in dummy_data_dict.items()}

          return dummy_data_dict
   def      __magic_name__     (     self      ,       _a      ,       _a							):
          lowercase       :							Union[str, Any]									=				[]
          # trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
          lowercase       :							Any									=				all(bool(re.findall("[0-9]{3,}-of-[0-9]{3,}"      ,       _a							)							) for url in data_url							)
          lowercase       :							List[Any]									=				all(
              url.startswith("https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed"							) for url in data_url							)
          if data_url and (is_tf_records or is_pubmed_records):
                 lowercase       :							Tuple									=				[data_url[0]] * len(_a							)
          for single_url in data_url:
                 for download_callback in self.download_callbacks:
                        download_callback(_a							)
                 # we force the name of each key to be the last file / folder name of the url path
                 # if the url has arguments, we need to encode them with urllib.parse.quote_plus
                 lowercase       :							Union[str, Any]									=				os.path.join(_a      ,       urllib.parse.quote_plus(single_url.split("/"							)[-1]							)							)
                 dummy_data_list.append(_a							)
          return dummy_data_list
   def      __magic_name__     (     self      ,       _a      ,       _a							):
          for download_callback in self.download_callbacks:
                 download_callback(_a							)
          # we force the name of each key to be the last file / folder name of the url path
          # if the url has arguments, we need to encode them with urllib.parse.quote_plus
          lowercase       :							Tuple									=				os.path.join(_a      ,       urllib.parse.quote_plus(data_url.split("/"							)[-1]							)							)
          if os.path.exists(_a							) or not self.load_existing_dummy_data:
                 return value
          else:
                 # Backward compatibility, maybe deprecate at one point.
                 # For many datasets with single url calls to dl_manager.download_and_extract,
                 # the dummy_data.zip file is actually the zipped downloaded file
                 # while now we expected the dummy_data.zip file to be a directory containing
                 # the downloaded file.
                 return path_to_dummy_data
   def      __magic_name__     (     self							):
          pass
   def      __magic_name__     (     self							):
          pass
   def      __magic_name__     (     self      ,       _a							):
          def _iter_archive_members(_a							):
                 # this preserves the order of the members inside the ZIP archive
                 lowercase       :							Optional[int]									=				Path(self.dummy_file							).parent
                 lowercase       :							List[str]									=				path.relative_to(_a							)
                 with ZipFile(self.local_path_to_dummy_data							) as zip_file:
                        lowercase       :							List[str]									=				zip_file.namelist()
                 for member in members:
                        if member.startswith(relative_path.as_posix()							):
                               yield dummy_parent_path.joinpath(_a							)

          lowercase       :							Union[str, Any]									=				Path(_a							)
          lowercase       :							List[Any]									=				_iter_archive_members(_a							) if self.use_local_dummy_data else path.rglob("*"							)
          for file_path in file_paths:
                 if file_path.is_file() and not file_path.name.startswith((".", "__")							):
                        yield file_path.relative_to(_a							).as_posix(), file_path.open("rb"							)

   def      __magic_name__     (     self      ,       _a							):
          if not isinstance(_a      ,       _a							):
                 lowercase       :							Any									=				[paths]
          for path in paths:
                 if os.path.isfile(_a							):
                        if os.path.basename(_a							).startswith((".", "__")							):
                               return
                        yield path
                 else:
                        for dirpath, dirnames, filenames in os.walk(_a							):
                               if os.path.basename(_a							).startswith((".", "__")							):
                                      continue
                               dirnames.sort()
                               for filename in sorted(_a							):
                                      if filename.startswith((".", "__")							):
                                             continue
                                      yield os.path.join(_a      ,       _a							)


