






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							)							)







from queue import Queue
from typing import TYPE_CHECKING, Optional


if TYPE_CHECKING:
  from ..models.auto import AutoTokenizer
class 		SCREAMING_SNAKE_CASE__	:

  '''simple docstring'''







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


         """simple docstring"""
         raise NotImplementedError()





  def  lowerCamelCase       (      self		:			Any							)						->	Any:


         """simple docstring"""
         raise NotImplementedError()



class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase     ):

  '''simple docstring'''







  def __init__(      self		:			str       ,				lowerCamelCase		:			"AutoTokenizer"       ,				lowerCamelCase		:			bool = False       ,				**lowerCamelCase		:			Any							)						->	Dict:


         """simple docstring"""
         _UpperCAmelCase							=    tokenizer
         _UpperCAmelCase							=    skip_prompt
         _UpperCAmelCase							=    decode_kwargs

         # variables used in the streaming process
         _UpperCAmelCase							=    []
         _UpperCAmelCase							=    0
         _UpperCAmelCase							=    True


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


         """simple docstring"""
         if len(value.shape							) > 1 and value.shape[0] > 1:
                raise ValueError("""TextStreamer only supports batch size 1"""							)
         elif len(value.shape							) > 1:
                _UpperCAmelCase							=    value[0]

         if self.skip_prompt and self.next_tokens_are_prompt:
                _UpperCAmelCase							=    False
                return

         # Add the new token to the cache and decodes the entire thing.
         self.token_cache.extend(value.tolist()							)
         _UpperCAmelCase							=    self.tokenizer.decode(self.token_cache       ,				**self.decode_kwargs							)

         # After the symbol for a new line, we flush the cache.
         if text.endswith("""\n"""							):
                _UpperCAmelCase							=    text[self.print_len :]
                _UpperCAmelCase							=    []
                _UpperCAmelCase							=    0
         # If the last token is a CJK character, we print the characters.
         elif len(lowerCamelCase							) > 0 and self._is_chinese_char(ord(text[-1]							)							):
                _UpperCAmelCase							=    text[self.print_len :]
                self.print_len += len(lowerCamelCase							)
         # Otherwise, prints until the last space char (simple heuristic to avoid printing incomplete words,
         # which may change with the subsequent token -- there are probably smarter ways to do this!)
         else:
                _UpperCAmelCase							=    text[self.print_len : text.rfind(""" """							) + 1]
                self.print_len += len(lowerCamelCase							)

         self.on_finalized_text(lowerCamelCase							)


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


         """simple docstring"""
         # Flush the cache, if it exists
         if len(self.token_cache							) > 0:
                _UpperCAmelCase							=    self.tokenizer.decode(self.token_cache       ,				**self.decode_kwargs							)
                _UpperCAmelCase							=    text[self.print_len :]
                _UpperCAmelCase							=    []
                _UpperCAmelCase							=    0
         else:
                _UpperCAmelCase							=    """"""

         _UpperCAmelCase							=    True
         self.on_finalized_text(lowerCamelCase       ,				stream_end=lowerCamelCase							)


  def  lowerCamelCase       (      self		:			Optional[int]       ,				lowerCamelCase		:			str       ,				lowerCamelCase		:			bool = False							)						->	Any:


         """simple docstring"""
         print(lowerCamelCase       ,				flush=lowerCamelCase       ,				end="""""" if not stream_end else None							)





  def  lowerCamelCase       (      self		:			int       ,				lowerCamelCase		:			Any							)						->	int:


         """simple docstring"""
         # This defines a "chinese character" as anything in the CJK Unicode block:
         #   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
         #
         # Note that the CJK Unicode block is NOT all Japanese and Korean characters,
         # despite its name. The modern Korean Hangul alphabet is a different block,
         # as is Japanese Hiragana and Katakana. Those alphabets are used to write
         # space-separated words, so they are not treated specially and handled
         # like the all of the other languages.
         if (
             (cp >= 0X4E00 and cp <= 0X9FFF)
             or (cp >= 0X3400 and cp <= 0X4DBF)  #
             or (cp >= 0X2_0000 and cp <= 0X2_A6DF)  #
             or (cp >= 0X2_A700 and cp <= 0X2_B73F)  #
             or (cp >= 0X2_B740 and cp <= 0X2_B81F)  #
             or (cp >= 0X2_B820 and cp <= 0X2_CEAF)  #
             or (cp >= 0XF900 and cp <= 0XFAFF)
             or (cp >= 0X2_F800 and cp <= 0X2_FA1F)  #
         ):  #
                return True

         return False



class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase     ):

  '''simple docstring'''







  def __init__(      self		:			Optional[int]       ,				lowerCamelCase		:			"AutoTokenizer"       ,				lowerCamelCase		:			bool = False       ,				lowerCamelCase		:			Optional[float] = None       ,				**lowerCamelCase		:			Optional[Any]							)						->	Tuple:


         """simple docstring"""
         super().__init__(lowerCamelCase       ,				lowerCamelCase       ,				**lowerCamelCase							)
         _UpperCAmelCase							=    Queue()
         _UpperCAmelCase							=    None
         _UpperCAmelCase							=    timeout


  def  lowerCamelCase       (      self		:			Optional[Any]       ,				lowerCamelCase		:			str       ,				lowerCamelCase		:			bool = False							)						->	Optional[int]:


         """simple docstring"""
         self.text_queue.put(lowerCamelCase       ,				timeout=self.timeout							)
         if stream_end:
                self.text_queue.put(self.stop_signal       ,				timeout=self.timeout							)


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


         """simple docstring"""
         return self





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


         """simple docstring"""
         _UpperCAmelCase							=    self.text_queue.get(timeout=self.timeout							)
         if value == self.stop_signal:
                raise StopIteration()
         else:
                return value