






import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_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 torch import nn

 from transformers import MaskFormerSwinBackbone
 from transformers.models.maskformer import MaskFormerSwinModel





class 			__a  :







 def __init__(		self					:   Tuple							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   List[str]=13							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=32							,   SCREAMING_SNAKE_CASE					:   str=2							,   SCREAMING_SNAKE_CASE					:   List[str]=3							,   SCREAMING_SNAKE_CASE					:   List[str]=16							,   SCREAMING_SNAKE_CASE					:   Dict=[1, 2, 1]							,   SCREAMING_SNAKE_CASE					:   Dict=[2, 2, 4]							,   SCREAMING_SNAKE_CASE					:   List[Any]=2							,   SCREAMING_SNAKE_CASE					:   Optional[int]=2.0							,   SCREAMING_SNAKE_CASE					:   int=True							,   SCREAMING_SNAKE_CASE					:   Optional[int]=0.0							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]=0.0							,   SCREAMING_SNAKE_CASE					:   Dict=0.1							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]="gelu"							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=False							,   SCREAMING_SNAKE_CASE					:   List[Any]=True							,   SCREAMING_SNAKE_CASE					:   int=0.0_2							,   SCREAMING_SNAKE_CASE					:   int=1e-5							,   SCREAMING_SNAKE_CASE					:   str=True							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=None							,   SCREAMING_SNAKE_CASE					:   Optional[int]=True							,   SCREAMING_SNAKE_CASE					:   List[str]=10							,   SCREAMING_SNAKE_CASE					:   int=8							,   SCREAMING_SNAKE_CASE					:   Optional[int]=["stage1", "stage2", "stage3"]							,   SCREAMING_SNAKE_CASE					:   List[str]=[1, 2, 3]							,   ):


      '''simple docstring'''






      UpperCamelCase__			:   int       				=  parent
      UpperCamelCase__			:   Any       				=  batch_size
      UpperCamelCase__			:   Any       				=  image_size
      UpperCamelCase__			:   Dict       				=  patch_size
      UpperCamelCase__			:   int       				=  num_channels
      UpperCamelCase__			:   int       				=  embed_dim
      UpperCamelCase__			:   List[Any]       				=  depths
      UpperCamelCase__			:   Any       				=  num_heads
      UpperCamelCase__			:   Any       				=  window_size
      UpperCamelCase__			:   Union[str, Any]       				=  mlp_ratio
      UpperCamelCase__			:   Optional[int]       				=  qkv_bias
      UpperCamelCase__			:   int       				=  hidden_dropout_prob
      UpperCamelCase__			:   List[str]       				=  attention_probs_dropout_prob
      UpperCamelCase__			:   Tuple       				=  drop_path_rate
      UpperCamelCase__			:   str       				=  hidden_act
      UpperCamelCase__			:   str       				=  use_absolute_embeddings
      UpperCamelCase__			:   str       				=  patch_norm
      UpperCamelCase__			:   Optional[int]       				=  layer_norm_eps
      UpperCamelCase__			:   List[str]       				=  initializer_range
      UpperCamelCase__			:   Any       				=  is_training
      UpperCamelCase__			:   Any       				=  scope
      UpperCamelCase__			:   Any       				=  use_labels
      UpperCamelCase__			:   str       				=  type_sequence_label_size
      UpperCamelCase__			:   int       				=  encoder_stride
      UpperCamelCase__			:   Tuple       				=  out_features
      UpperCamelCase__			:   str       				=  out_indices







 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[int]       				=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

      UpperCamelCase__			:   List[str]       				=  None
      if self.use_labels:
           UpperCamelCase__			:   int       				=  ids_tensor([self.batch_size]							,   self.type_sequence_label_size						)

      UpperCamelCase__			:   Union[str, Any]       				=  self.get_config()

      return config, pixel_values, labels







 def 					__lowercase					(		self					:   Optional[int]						):


      '''simple docstring'''






      return MaskFormerSwinConfig(
          image_size=self.image_size							,   patch_size=self.patch_size							,   num_channels=self.num_channels							,   embed_dim=self.embed_dim							,   depths=self.depths							,   num_heads=self.num_heads							,   window_size=self.window_size							,   mlp_ratio=self.mlp_ratio							,   qkv_bias=self.qkv_bias							,   hidden_dropout_prob=self.hidden_dropout_prob							,   attention_probs_dropout_prob=self.attention_probs_dropout_prob							,   drop_path_rate=self.drop_path_rate							,   hidden_act=self.hidden_act							,   use_absolute_embeddings=self.use_absolute_embeddings							,   path_norm=self.patch_norm							,   layer_norm_eps=self.layer_norm_eps							,   initializer_range=self.initializer_range							,   encoder_stride=self.encoder_stride							,   out_features=self.out_features							,   out_indices=self.out_indices							,   )







 def 					__lowercase					(		self					:   List[str]							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   List[str]							,   SCREAMING_SNAKE_CASE					:   Dict						):


      '''simple docstring'''






      UpperCamelCase__			:   Union[str, Any]       				=  MaskFormerSwinModel(config=__lowercase						)
      model.to(__lowercase						)
      model.eval()
      UpperCamelCase__			:   int       				=  model(__lowercase						)

      UpperCamelCase__			:   Tuple       				=  ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
      UpperCamelCase__			:   List[str]       				=  int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

      self.parent.assertEqual(result.last_hidden_state.shape							,   (self.batch_size, expected_seq_len, expected_dim)						)







 def 					__lowercase					(		self					:   int							,   SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   Tuple							,   SCREAMING_SNAKE_CASE					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   Dict       				=  MaskFormerSwinBackbone(config=__lowercase						)
      model.to(__lowercase						)
      model.eval()
      UpperCamelCase__			:   List[Any]       				=  model(__lowercase						)

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps						)							,   len(config.out_features						)						)
      self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,   [13, 16, 16, 16]						)

      # verify channels
      self.parent.assertEqual(len(model.channels						)							,   len(config.out_features						)						)
      self.parent.assertListEqual(model.channels							,   [16, 32, 64]						)

      # verify ValueError
      with self.parent.assertRaises(__lowercase						):
           UpperCamelCase__			:   Any       				=  ["stem"]
           UpperCamelCase__			:   Tuple       				=  MaskFormerSwinBackbone(config=__lowercase						)







 def 					__lowercase					(		self					:   Optional[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  self.prepare_config_and_inputs()
      UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__			:   int       				=  config_and_inputs
      UpperCamelCase__			:   str       				=  {"pixel_values": pixel_values}
      return config, inputs_dict







@require_torch
class 			__a  (    UpperCAmelCase__       ,   UpperCAmelCase__       ,   unittest.TestCase       ):
 _lowerCAmelCase       :       List[str]        = (
     (
         MaskFormerSwinModel,
         MaskFormerSwinBackbone,
     )
     if is_torch_available()
     else ()
 )
 _lowerCAmelCase       :       Union[str, Any]        = {'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
 _lowerCAmelCase       :       Union[str, Any]        = False
 _lowerCAmelCase       :       Dict        = False
 _lowerCAmelCase       :       List[str]        = False
 _lowerCAmelCase       :       Optional[Any]        = False
 _lowerCAmelCase       :       List[str]        = False







 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   Any       				=  MaskFormerSwinModelTester(self						)
      UpperCamelCase__			:   Dict       				=  ConfigTester(self							,   config_class=__lowercase							,   embed_dim=37						)







 @require_torch_multi_gpu
 @unittest.skip(
     reason=(
         "`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"
         " `nn.DataParallel`"
     )						)
 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      pass







 def 					__lowercase					(		self					:   Optional[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 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      return







 def 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      UpperCamelCase__			:   List[Any]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__lowercase						)







 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      UpperCamelCase__			:   List[Any]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*__lowercase						)







 @unittest.skip("Swin does not use inputs_embeds"						)
 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      pass







 @unittest.skip("Swin does not support feedforward chunking"						)
 def 					__lowercase					(		self					:   Optional[int]						):


      '''simple docstring'''






      pass







 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   List[str]       				=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCamelCase__			:   List[Any]       				=  model_class(__lowercase						)
           self.assertIsInstance(model.get_input_embeddings()							,   (nn.Module)						)
           UpperCamelCase__			:   int       				=  model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(__lowercase							,   nn.Linear						)						)







 def 					__lowercase					(		self					:   Optional[Any]						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   int       				=  self.model_tester.prepare_config_and_inputs_for_common()

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

           UpperCamelCase__			:   Optional[int]       				=  ["pixel_values"]
           self.assertListEqual(arg_names[:1]							,   __lowercase						)







 @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions"						)
 def 					__lowercase					(		self					:   Optional[int]						):


      '''simple docstring'''






      pass







 @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone"						)
 def 					__lowercase					(		self					:   Any						):


      '''simple docstring'''






      pass







 def 					__lowercase					(		self					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   Dict							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   List[str]       				=  model_class(__lowercase						)
      model.to(__lowercase						)
      model.eval()

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

      UpperCamelCase__			:   Optional[Any]       				=  outputs.hidden_states

      UpperCamelCase__			:   Dict       				=  getattr(
          self.model_tester							,   "expected_num_hidden_layers"							,   len(self.model_tester.depths						) + 1						)
      self.assertEqual(len(__lowercase						)							,   __lowercase						)

      # Swin has a different seq_length
      UpperCamelCase__			:   Optional[Any]       				=  (
          config.patch_size
          if isinstance(config.patch_size							,   collections.abc.Iterable						)
          else (config.patch_size, config.patch_size)
      )

      UpperCamelCase__			:   Tuple       				=  (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

      self.assertListEqual(
          list(hidden_states[0].shape[-2:]						)							,   [num_patches, self.model_tester.embed_dim]							,   )







 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   str       				=  self.model_tester.prepare_config_and_inputs_for_common()

      UpperCamelCase__			:   List[Any]       				=  (
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size							,   collections.abc.Iterable						)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )

      for model_class in self.all_model_classes:
           UpperCamelCase__			:   int       				=  True
           self.check_hidden_states_output(__lowercase							,   __lowercase							,   __lowercase							,   __lowercase						)

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

           self.check_hidden_states_output(__lowercase							,   __lowercase							,   __lowercase							,   __lowercase						)







 def 					__lowercase					(		self					:   str						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   str       				=  self.model_tester.prepare_config_and_inputs_for_common()
      UpperCamelCase__			:   str       				=  3

      UpperCamelCase__			:   List[str]       				=  (
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size							,   collections.abc.Iterable						)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )
      UpperCamelCase__			:   Dict       				=  (
          config.patch_size
          if isinstance(config.patch_size							,   collections.abc.Iterable						)
          else (config.patch_size, config.patch_size)
      )

      UpperCamelCase__			:   List[Any]       				=  image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      UpperCamelCase__			:   Optional[Any]       				=  image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes:
           UpperCamelCase__			:   int       				=  True
           self.check_hidden_states_output(__lowercase							,   __lowercase							,   __lowercase							,   (padded_height, padded_width)						)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           UpperCamelCase__			:   str       				=  True
           self.check_hidden_states_output(__lowercase							,   __lowercase							,   __lowercase							,   (padded_height, padded_width)						)







 @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints"						)
 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      pass







 @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"						)
 def 					__lowercase					(		self					:   str						):


      '''simple docstring'''






      pass







 @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"						)
 def 					__lowercase					(		self					:   Optional[Any]						):


      '''simple docstring'''






      pass







 def 					__lowercase					(		self					:   int						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   Optional[Any]       				=  self.model_tester.prepare_config_and_inputs_for_common()

      def set_nan_tensor_to_zero(SCREAMING_SNAKE_CASE					:   Any						):
           UpperCamelCase__			:   List[str]       				=  0
           return t

      def check_equivalence(SCREAMING_SNAKE_CASE					:   List[str]							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   List[str]							,   SCREAMING_SNAKE_CASE					:   List[Any]={}						):
           with torch.no_grad():
                UpperCamelCase__			:   str       				=  model(**__lowercase							,   return_dict=__lowercase							,   **__lowercase						)
                UpperCamelCase__			:   Union[str, Any]       				=  model(**__lowercase							,   return_dict=__lowercase							,   **__lowercase						).to_tuple()

                def recursive_check(SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   int						):
                     if isinstance(__lowercase							,   (List, Tuple)						):
                          for tuple_iterable_value, dict_iterable_value in zip(__lowercase							,   __lowercase						):
                               recursive_check(__lowercase							,   __lowercase						)
                     elif isinstance(__lowercase							,   __lowercase						):
                          for tuple_iterable_value, dict_iterable_value in zip(
                              tuple_object.values()							,   dict_object.values()						):
                               recursive_check(__lowercase							,   __lowercase						)
                     elif tuple_object is None:
                          return
                     else:
                          self.assertTrue(
                              torch.allclose(
                                  set_nan_tensor_to_zero(__lowercase						)							,   set_nan_tensor_to_zero(__lowercase						)							,   atol=1e-5						)							,   msg=(
                                  "Tuple and dict output are not equal. Difference:"
                                  F' {torch.max(torch.abs(tuple_object - dict_object						)						)}. Tuple has `nan`:'
                                  F' {torch.isnan(__lowercase						).any()} and `inf`: {torch.isinf(__lowercase						)}. Dict has'
                                  F' `nan`: {torch.isnan(__lowercase						).any()} and `inf`: {torch.isinf(__lowercase						)}.'
                              )							,   )

                recursive_check(__lowercase							,   __lowercase						)

      for model_class in self.all_model_classes:
           UpperCamelCase__			:   List[str]       				=  model_class(__lowercase						)
           model.to(__lowercase						)
           model.eval()

           UpperCamelCase__			:   Any       				=  self._prepare_for_class(__lowercase							,   __lowercase						)
           UpperCamelCase__			:   Optional[Any]       				=  self._prepare_for_class(__lowercase							,   __lowercase						)
           check_equivalence(__lowercase							,   __lowercase							,   __lowercase						)

           UpperCamelCase__			:   List[str]       				=  self._prepare_for_class(__lowercase							,   __lowercase							,   return_labels=__lowercase						)
           UpperCamelCase__			:   str       				=  self._prepare_for_class(__lowercase							,   __lowercase							,   return_labels=__lowercase						)
           check_equivalence(__lowercase							,   __lowercase							,   __lowercase						)

           UpperCamelCase__			:   List[Any]       				=  self._prepare_for_class(__lowercase							,   __lowercase						)
           UpperCamelCase__			:   Optional[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__			:   int       				=  self._prepare_for_class(__lowercase							,   __lowercase							,   return_labels=__lowercase						)
           check_equivalence(__lowercase							,   __lowercase							,   __lowercase							,   {"output_hidden_states": True}						)







@require_torch
class 			__a  (    unittest.TestCase       ,   UpperCAmelCase__       ):
 _lowerCAmelCase       :       Tuple        = (MaskFormerSwinBackbone,) if is_torch_available() else ()
 _lowerCAmelCase       :       int        = MaskFormerSwinConfig







 def 					__lowercase					(		self					:   Union[str, Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Dict       				=  MaskFormerSwinModelTester(self						)







 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      UpperCamelCase__				,     UpperCamelCase__			:   Dict       				=  self.model_tester.prepare_config_and_inputs_for_common()
      UpperCamelCase__			:   int       				=  inputs_dict["pixel_values"].shape[0]

      for backbone_class in self.all_model_classes:
           UpperCamelCase__			:   int       				=  backbone_class(__lowercase						)
           backbone.to(__lowercase						)
           backbone.eval()

           UpperCamelCase__			:   str       				=  backbone(**__lowercase						)

           # Test default outputs and verify feature maps
           self.assertIsInstance(outputs.feature_maps							,   __lowercase						)
           self.assertTrue(len(outputs.feature_maps						) == len(backbone.channels						)						)
           for feature_map, n_channels in zip(outputs.feature_maps							,   backbone.channels						):
                self.assertTrue(feature_map.shape[:2]							,   (batch_size, n_channels)						)
           self.assertIsNone(outputs.hidden_states						)
           self.assertIsNone(outputs.attentions						)

           # Test output_hidden_states=True
           UpperCamelCase__			:   Dict       				=  backbone(**__lowercase							,   output_hidden_states=__lowercase						)
           self.assertIsNotNone(outputs.hidden_states						)
           self.assertTrue(len(outputs.hidden_states						)							,   len(backbone.stage_names						)						)
           # We skip the stem layer
           for hidden_states, n_channels in zip(outputs.hidden_states[1:]							,   backbone.channels						):
                for hidden_state in hidden_states:
                     # Hidden states are in the format (batch_size, (height * width), n_channels)
                     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__			:   Optional[int]       				=  hidden_state.shape
                     self.assertTrue((h_batch_size, h_n_channels)							,   (batch_size, n_channels)						)

            # Test output_attentions=True
           if self.has_attentions:
                UpperCamelCase__			:   Dict       				=  backbone(**__lowercase							,   output_attentions=__lowercase						)
                self.assertIsNotNone(outputs.attentions						)





import functools


def 						lowerCamelCase__    (		_A     ,	_A							):







	'''simple docstring'''





	if not isinstance(_A     ,	_A							) or not all(isinstance(_A     ,	_A							) for day in days							):
		raise ValueError("The parameter days should be a list of integers"							)

	if len(_A							) != 3 or not all(isinstance(_A     ,	_A							) for cost in costs							):
		raise ValueError("The parameter costs should be a list of three integers"							)

	if len(_A							) == 0:
		return 0

	if min(_A							) <= 0:
		raise ValueError("All days elements should be greater than 0"							)

	if max(_A							) >= 366:
		raise ValueError("All days elements should be less than 366"							)

	snake_case_		    =     set(_A							)

	@functools.cache
	def dynamic_programming(_A							) -> int:
		if index > 365:
			return 0

		if index not in days_set:
			return dynamic_programming(index + 1							)

		return min(
		    costs[0] + dynamic_programming(index + 1							)     ,	costs[1] + dynamic_programming(index + 7							)     ,	costs[2] + dynamic_programming(index + 30							)     ,	)

	return dynamic_programming(1							)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
