




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




							'''simple docstring'''



							def __init__(					self       :	Optional[Any]       ,     a       :	Optional[int]       ,     a       :	Dict=13       ,     a       :	List[str]=32       ,     a       :	int=2       ,     a       :	Optional[Any]=3       ,     a       :	str=16       ,     a       :	Tuple=[1, 2, 1]       ,     a       :	Dict=[2, 2, 4]       ,     a       :	Dict=2       ,     a       :	str=2.0       ,     a       :	List[Any]=True       ,     a       :	int=0.0       ,     a       :	int=0.0       ,     a       :	Union[str, Any]=0.1       ,     a       :	int="gelu"       ,     a       :	Any=False       ,     a       :	Tuple=True       ,     a       :	str=0.02       ,     a       :	Optional[int]=1E-5       ,     a       :	List[str]=True       ,     a       :	Union[str, Any]=None       ,     a       :	Optional[int]=True       ,     a       :	Any=10       ,     a       :	Union[str, Any]=8       ,     a       :	Tuple=["stage1", "stage2", "stage3"]       ,     a       :	int=[1, 2, 3]       ,     )			->					str:
										SCREAMING_SNAKE_CASE           =					parent
										SCREAMING_SNAKE_CASE           =					batch_size
										SCREAMING_SNAKE_CASE           =					image_size
										SCREAMING_SNAKE_CASE           =					patch_size
										SCREAMING_SNAKE_CASE           =					num_channels
										SCREAMING_SNAKE_CASE           =					embed_dim
										SCREAMING_SNAKE_CASE           =					depths
										SCREAMING_SNAKE_CASE           =					num_heads
										SCREAMING_SNAKE_CASE           =					window_size
										SCREAMING_SNAKE_CASE           =					mlp_ratio
										SCREAMING_SNAKE_CASE           =					qkv_bias
										SCREAMING_SNAKE_CASE           =					hidden_dropout_prob
										SCREAMING_SNAKE_CASE           =					attention_probs_dropout_prob
										SCREAMING_SNAKE_CASE           =					drop_path_rate
										SCREAMING_SNAKE_CASE           =					hidden_act
										SCREAMING_SNAKE_CASE           =					use_absolute_embeddings
										SCREAMING_SNAKE_CASE           =					patch_norm
										SCREAMING_SNAKE_CASE           =					layer_norm_eps
										SCREAMING_SNAKE_CASE           =					initializer_range
										SCREAMING_SNAKE_CASE           =					is_training
										SCREAMING_SNAKE_CASE           =					scope
										SCREAMING_SNAKE_CASE           =					use_labels
										SCREAMING_SNAKE_CASE           =					type_sequence_label_size
										SCREAMING_SNAKE_CASE           =					encoder_stride
										SCREAMING_SNAKE_CASE           =					out_features
										SCREAMING_SNAKE_CASE           =					out_indices





							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					int:
										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

										SCREAMING_SNAKE_CASE           =					self.get_config()

										return config, pixel_values, labels





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					str:
										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    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	int       ,     a       :	str       ,     a       :	Any			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					MaskFormerSwinModel(config=a			)
										model.to(a			)
										model.eval()
										SCREAMING_SNAKE_CASE           =					model(a			)

										SCREAMING_SNAKE_CASE           =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
										SCREAMING_SNAKE_CASE           =					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    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Union[str, Any]       ,     a       :	List[str]       ,     a       :	List[Any]			)			->					Dict:
										SCREAMING_SNAKE_CASE           =					MaskFormerSwinBackbone(config=a			)
										model.to(a			)
										model.eval()
										SCREAMING_SNAKE_CASE           =					model(a			)

										# 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(a			):
													SCREAMING_SNAKE_CASE           =					["""stem"""]
													SCREAMING_SNAKE_CASE           =					MaskFormerSwinBackbone(config=a			)







							def    _UpperCAmelCase     (					self       :	List[str]			)			->					int:
										SCREAMING_SNAKE_CASE           =					self.prepare_config_and_inputs()
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					config_and_inputs
										SCREAMING_SNAKE_CASE           =					{"""pixel_values""": pixel_values}
										return config, inputs_dict





@require_torch
class 			UpperCAmelCase_      (   A		,      A		,      unittest.TestCase       ):




							'''simple docstring'''



							a__						  =     (
							    (
							        MaskFormerSwinModel,
							        MaskFormerSwinBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							a__						  =     {'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
							a__						  =     False
							a__						  =     False
							a__						  =     False
							a__						  =     False
							a__						  =     False





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					MaskFormerSwinModelTester(self			)
										SCREAMING_SNAKE_CASE           =					ConfigTester(self       ,     config_class=a       ,     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    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					str:
										pass





							def    _UpperCAmelCase     (					self       :	Any			)			->					Tuple:
										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    _UpperCAmelCase     (					self       :	Tuple			)			->					Tuple:
										return





							def    _UpperCAmelCase     (					self       :	Any			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*a			)





							def    _UpperCAmelCase     (					self       :	Any			)			->					List[str]:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*a			)





							@unittest.skip("""Swin does not use inputs_embeds"""			)
							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					Tuple:
										pass





							@unittest.skip("""Swin does not support feedforward chunking"""			)
							def    _UpperCAmelCase     (					self       :	str			)			->					Tuple:
										pass





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					List[str]:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					model_class(a			)
													self.assertIsInstance(model.get_input_embeddings()       ,     (nn.Module)			)
													SCREAMING_SNAKE_CASE           =					model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(a       ,     nn.Linear			)			)





							def    _UpperCAmelCase     (					self       :	str			)			->					Any:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

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

													SCREAMING_SNAKE_CASE           =					["""pixel_values"""]
													self.assertListEqual(arg_names[:1]       ,     a			)





							@unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""			)
							def    _UpperCAmelCase     (					self       :	Dict			)			->					Optional[Any]:
										pass





							@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""			)
							def    _UpperCAmelCase     (					self       :	List[Any]			)			->					int:
										pass





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	Optional[Any]       ,     a       :	Any       ,     a       :	Tuple       ,     a       :	Optional[Any]			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					model_class(a			)
										model.to(a			)
										model.eval()

										with torch.no_grad():
													SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(a       ,     a			)			)

										SCREAMING_SNAKE_CASE           =					outputs.hidden_states

										SCREAMING_SNAKE_CASE           =					getattr(
										    self.model_tester       ,     """expected_num_hidden_layers"""       ,     len(self.model_tester.depths			) + 1			)
										self.assertEqual(len(a			)       ,     a			)

										# Swin has a different seq_length
										SCREAMING_SNAKE_CASE           =					(
										    config.patch_size
										    if isinstance(config.patch_size       ,     collections.abc.Iterable			)
										    else (config.patch_size, config.patch_size)
										)

										SCREAMING_SNAKE_CASE           =					(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    _UpperCAmelCase     (					self       :	Dict			)			->					str:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

										SCREAMING_SNAKE_CASE           =					(
										    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:
													SCREAMING_SNAKE_CASE           =					True
													self.check_hidden_states_output(a       ,     a       ,     a       ,     a			)

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

													self.check_hidden_states_output(a       ,     a       ,     a       ,     a			)





							def    _UpperCAmelCase     (					self       :	Any			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE           =					3

										SCREAMING_SNAKE_CASE           =					(
										    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)
										)
										SCREAMING_SNAKE_CASE           =					(
										    config.patch_size
										    if isinstance(config.patch_size       ,     collections.abc.Iterable			)
										    else (config.patch_size, config.patch_size)
										)

										SCREAMING_SNAKE_CASE           =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
										SCREAMING_SNAKE_CASE           =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					True
													self.check_hidden_states_output(a       ,     a       ,     a       ,     (padded_height, padded_width)			)

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													SCREAMING_SNAKE_CASE           =					True
													self.check_hidden_states_output(a       ,     a       ,     a       ,     (padded_height, padded_width)			)





							@unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""			)
							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					int:
										pass





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





							@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""			)
							def    _UpperCAmelCase     (					self       :	List[str]			)			->					List[str]:
										pass







							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					int:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

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

										def check_equivalence(a       :	Tuple       ,     a       :	Optional[Any]       ,     a       :	Optional[Any]       ,     a       :	Dict={}			):
													with torch.no_grad():
																SCREAMING_SNAKE_CASE           =					model(**a       ,     return_dict=a       ,     **a			)
																SCREAMING_SNAKE_CASE           =					model(**a       ,     return_dict=a       ,     **a			).to_tuple()

																def recursive_check(a       :	List[Any]       ,     a       :	str			):
																			if isinstance(a       ,     (List, Tuple)			):
																						for tuple_iterable_value, dict_iterable_value in zip(a       ,     a			):
																									recursive_check(a       ,     a			)
																			elif isinstance(a       ,     a			):
																						for tuple_iterable_value, dict_iterable_value in zip(
																						    tuple_object.values()       ,     dict_object.values()			):
																									recursive_check(a       ,     a			)
																			elif tuple_object is None:
																						return
																			else:
																						self.assertTrue(
																						    torch.allclose(
																						        set_nan_tensor_to_zero(a			)       ,     set_nan_tensor_to_zero(a			)       ,     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(a			).any()} and `inf`: {torch.isinf(a			)}. Dict has"""
																						        f""" `nan`: {torch.isnan(a			).any()} and `inf`: {torch.isinf(a			)}."""
																						    )       ,     )

																recursive_check(a       ,     a			)

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					model_class(a			)
													model.to(a			)
													model.eval()

													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a			)
													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a			)
													check_equivalence(a       ,     a       ,     a			)

													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a       ,     return_labels=a			)
													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a       ,     return_labels=a			)
													check_equivalence(a       ,     a       ,     a			)

													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a			)
													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a			)
													check_equivalence(a       ,     a       ,     a       ,     {"""output_hidden_states""": True}			)

													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a       ,     return_labels=a			)
													SCREAMING_SNAKE_CASE           =					self._prepare_for_class(a       ,     a       ,     return_labels=a			)
													check_equivalence(a       ,     a       ,     a       ,     {"""output_hidden_states""": True}			)





@require_torch
class 			UpperCAmelCase_      (   unittest.TestCase		,      A       ):




							'''simple docstring'''



							a__						  =     (MaskFormerSwinBackbone,) if is_torch_available() else ()
							a__						  =     MaskFormerSwinConfig





							def    _UpperCAmelCase     (					self       :	str			)			->					str:
										SCREAMING_SNAKE_CASE           =					MaskFormerSwinModelTester(self			)







							def    _UpperCAmelCase     (					self       :	Dict			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE           =					inputs_dict["""pixel_values"""].shape[0]

										for backbone_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					backbone_class(a			)
													backbone.to(a			)
													backbone.eval()

													SCREAMING_SNAKE_CASE           =					backbone(**a			)

													# Test default outputs and verify feature maps
													self.assertIsInstance(outputs.feature_maps       ,     a			)
													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
													SCREAMING_SNAKE_CASE           =					backbone(**a       ,     output_hidden_states=a			)
													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)
																			SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					hidden_state.shape
																			self.assertTrue((h_batch_size, h_n_channels)       ,     (batch_size, n_channels)			)

            # Test output_attentions=True
													if self.has_attentions:
																SCREAMING_SNAKE_CASE           =					backbone(**a       ,     output_attentions=a			)
																self.assertIsNotNone(outputs.attentions			)












import importlib
import shutil
import threading
import warnings
from typing import List

import fsspec
import fsspec.asyn

from . import compression
from .hffilesystem import HfFileSystem


__A						:							Tuple							=  importlib.util.find_spec("""s3fs""") is not None

if _has_safs:
		from .safilesystem import SaFileSystem  # noqa: F401

__A						:							List[compression.BaseCompressedFileFileSystem]							=  [
    compression.BzaFileSystem,
    compression.GzipFileSystem,
    compression.LzaFileSystem,
    compression.XzFileSystem,
    compression.ZstdFileSystem,
]

# Register custom filesystems
for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]:
		if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
				warnings.warn(f'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''')
		fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if "://" in dataset_path:
						SCREAMING_SNAKE_CASE           =					dataset_path.split("""://"""   )[1]
			return dataset_path
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if fs is not None and fs.protocol != "file":
						return True
			else:
						return False
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					not is_remote_filesystem(SCREAMING_SNAKE_CASE   )
			if is_local:
						# LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
						shutil.move(fs._strip_protocol(SCREAMING_SNAKE_CASE   )					,	fs._strip_protocol(SCREAMING_SNAKE_CASE   )   )
			else:
						fs.mv(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	recursive=SCREAMING_SNAKE_CASE   )




def 					lowerCamelCase_    (    ):
			'''simple docstring'''
			if hasattr(fsspec.asyn					,	"""reset_lock"""   ):
						# for future fsspec>2022.05.0
						fsspec.asyn.reset_lock()
			else:
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					threading.Lock()






