
'''simple docstring'''







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      :


							def __init__(       self    ,   lowerCAmelCase_    ,   lowerCAmelCase_=13    ,   lowerCAmelCase_=32    ,   lowerCAmelCase_=2    ,   lowerCAmelCase_=3    ,   lowerCAmelCase_=16    ,   lowerCAmelCase_=[1, 2, 1]    ,   lowerCAmelCase_=[2, 2, 4]    ,   lowerCAmelCase_=2    ,   lowerCAmelCase_=2.0    ,   lowerCAmelCase_=True    ,   lowerCAmelCase_=0.0    ,   lowerCAmelCase_=0.0    ,   lowerCAmelCase_=0.1    ,   lowerCAmelCase_="gelu"    ,   lowerCAmelCase_=False    ,   lowerCAmelCase_=True    ,   lowerCAmelCase_=0.02    ,   lowerCAmelCase_=1E-5    ,   lowerCAmelCase_=True    ,   lowerCAmelCase_=None    ,   lowerCAmelCase_=True    ,   lowerCAmelCase_=10    ,   lowerCAmelCase_=8    ,   lowerCAmelCase_=["stage1", "stage2", "stage3"]    ,   lowerCAmelCase_=[1, 2, 3]    ,   ):





								"""simple docstring"""






								_snake_case   						=		parent
								_snake_case   						=		batch_size
								_snake_case   						=		image_size
								_snake_case   						=		patch_size
								_snake_case   						=		num_channels
								_snake_case   						=		embed_dim
								_snake_case   						=		depths
								_snake_case   						=		num_heads
								_snake_case   						=		window_size
								_snake_case   						=		mlp_ratio
								_snake_case   						=		qkv_bias
								_snake_case   						=		hidden_dropout_prob
								_snake_case   						=		attention_probs_dropout_prob
								_snake_case   						=		drop_path_rate
								_snake_case   						=		hidden_act
								_snake_case   						=		use_absolute_embeddings
								_snake_case   						=		patch_norm
								_snake_case   						=		layer_norm_eps
								_snake_case   						=		initializer_range
								_snake_case   						=		is_training
								_snake_case   						=		scope
								_snake_case   						=		use_labels
								_snake_case   						=		type_sequence_label_size
								_snake_case   						=		encoder_stride
								_snake_case   						=		out_features
								_snake_case   						=		out_indices


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

								_snake_case   						=		self.get_config()

								return config, pixel_values, labels


							def  lowerCamelCase				(       self  ):





								"""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  lowerCamelCase				(       self    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_  ):





								"""simple docstring"""






								_snake_case   						=		MaskFormerSwinModel(config=lowerCAmelCase_  )
								model.to(lowerCAmelCase_  )
								model.eval()
								_snake_case   						=		model(lowerCAmelCase_  )

								_snake_case   						=		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
								_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  lowerCamelCase				(       self    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_  ):





								"""simple docstring"""






								_snake_case   						=		MaskFormerSwinBackbone(config=lowerCAmelCase_  )
								model.to(lowerCAmelCase_  )
								model.eval()
								_snake_case   						=		model(lowerCAmelCase_  )

								# 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(lowerCAmelCase_  ):
									_snake_case   						=		['stem']
									_snake_case   						=		MaskFormerSwinBackbone(config=lowerCAmelCase_  )




							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		self.prepare_config_and_inputs()
								_snake_case						, _snake_case						, _snake_case   						=		config_and_inputs
								_snake_case   						=		{'pixel_values': pixel_values}
								return config, inputs_dict


@require_torch
class 						__UpperCAmelCase      (					_lowerCamelCase						,   _lowerCamelCase						,   unittest.TestCase						):
							__lowercase      		=       (
							    (
							        MaskFormerSwinModel,
							        MaskFormerSwinBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							__lowercase      		=       {"""feature-extraction""": MaskFormerSwinModel} if is_torch_available() else {}
							__lowercase      		=       False
							__lowercase      		=       False
							__lowercase      		=       False
							__lowercase      		=       False
							__lowercase      		=       False


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		MaskFormerSwinModelTester(self  )
								_snake_case   						=		ConfigTester(self    ,   config_class=lowerCAmelCase_    ,   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  lowerCamelCase				(       self  ):





								"""simple docstring"""






								pass


							def  lowerCamelCase				(       self  ):





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





								"""simple docstring"""






								return


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCAmelCase_  )


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*lowerCAmelCase_  )


							@unittest.skip('Swin does not use inputs_embeds'  )
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								pass


							@unittest.skip('Swin does not support feedforward chunking'  )
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								pass


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case						, _snake_case   						=		self.model_tester.prepare_config_and_inputs_for_common()

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


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case						, _snake_case   						=		self.model_tester.prepare_config_and_inputs_for_common()

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

									_snake_case   						=		['pixel_values']
									self.assertListEqual(arg_names[:1]    ,   lowerCAmelCase_  )


							@unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'  )
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								pass


							@unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'  )
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								pass


							def  lowerCamelCase				(       self    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_  ):





								"""simple docstring"""






								_snake_case   						=		model_class(lowerCAmelCase_  )
								model.to(lowerCAmelCase_  )
								model.eval()

								with torch.no_grad():
									_snake_case   						=		model(**self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_  )  )

								_snake_case   						=		outputs.hidden_states

								_snake_case   						=		getattr(
								    self.model_tester    ,   'expected_num_hidden_layers'    ,   len(self.model_tester.depths  ) + 1  )
								self.assertEqual(len(lowerCAmelCase_  )    ,   lowerCAmelCase_  )

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

								_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  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case						, _snake_case   						=		self.model_tester.prepare_config_and_inputs_for_common()

								_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:
									_snake_case   						=		True
									self.check_hidden_states_output(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_  )

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

									self.check_hidden_states_output(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_  )


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case						, _snake_case   						=		self.model_tester.prepare_config_and_inputs_for_common()
								_snake_case   						=		3

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

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

								for model_class in self.all_model_classes:
									_snake_case   						=		True
									self.check_hidden_states_output(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   (padded_height, padded_width)  )

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


							@unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'  )
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								pass


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





								"""simple docstring"""






								pass


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





								"""simple docstring"""






								pass




							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case						, _snake_case   						=		self.model_tester.prepare_config_and_inputs_for_common()

								def set_nan_tensor_to_zero(lowerCAmelCase_  ):
									_snake_case   						=		0
									return t

								def check_equivalence(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_={}  ):
									with torch.no_grad():
										_snake_case   						=		model(**lowerCAmelCase_    ,   return_dict=lowerCAmelCase_    ,   **lowerCAmelCase_  )
										_snake_case   						=		model(**lowerCAmelCase_    ,   return_dict=lowerCAmelCase_    ,   **lowerCAmelCase_  ).to_tuple()

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

										recursive_check(lowerCAmelCase_    ,   lowerCAmelCase_  )

								for model_class in self.all_model_classes:
									_snake_case   						=		model_class(lowerCAmelCase_  )
									model.to(lowerCAmelCase_  )
									model.eval()

									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_  )
									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_  )
									check_equivalence(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_  )

									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_    ,   return_labels=lowerCAmelCase_  )
									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_    ,   return_labels=lowerCAmelCase_  )
									check_equivalence(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_  )

									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_  )
									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_  )
									check_equivalence(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   {'output_hidden_states': True}  )

									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_    ,   return_labels=lowerCAmelCase_  )
									_snake_case   						=		self._prepare_for_class(lowerCAmelCase_    ,   lowerCAmelCase_    ,   return_labels=lowerCAmelCase_  )
									check_equivalence(lowerCAmelCase_    ,   lowerCAmelCase_    ,   lowerCAmelCase_    ,   {'output_hidden_states': True}  )


@require_torch
class 						__UpperCAmelCase      (					unittest.TestCase						,   _lowerCamelCase						):
							__lowercase      		=       (MaskFormerSwinBackbone,) if is_torch_available() else ()
							__lowercase      		=       MaskFormerSwinConfig


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		MaskFormerSwinModelTester(self  )




							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case						, _snake_case   						=		self.model_tester.prepare_config_and_inputs_for_common()
								_snake_case   						=		inputs_dict['pixel_values'].shape[0]

								for backbone_class in self.all_model_classes:
									_snake_case   						=		backbone_class(lowerCAmelCase_  )
									backbone.to(lowerCAmelCase_  )
									backbone.eval()

									_snake_case   						=		backbone(**lowerCAmelCase_  )

									# Test default outputs and verify feature maps
									self.assertIsInstance(outputs.feature_maps    ,   lowerCAmelCase_  )
									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
									_snake_case   						=		backbone(**lowerCAmelCase_    ,   output_hidden_states=lowerCAmelCase_  )
									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)
											_snake_case						, _snake_case						, _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:
										_snake_case   						=		backbone(**lowerCAmelCase_    ,   output_attentions=lowerCAmelCase_  )
										self.assertIsNotNone(outputs.attentions  )



'''simple docstring'''







import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch


class 						__UpperCAmelCase      (					_lowerCamelCase						):


							@require_torch
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

								_snake_case   						=		'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

								_snake_case   						=		'\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")\nsocket.socket = offline_socket\n        '

								# Force fetching the files so that we can use the cache
								_snake_case   						=		'hf-internal-testing/tiny-random-bert'
								BertConfig.from_pretrained(lowerCAmelCase_  )
								BertModel.from_pretrained(lowerCAmelCase_  )
								BertTokenizer.from_pretrained(lowerCAmelCase_  )
								pipeline(task='fill-mask'    ,   model=lowerCAmelCase_  )

								# baseline - just load from_pretrained with normal network
								_snake_case   						=		[sys.executable, '-c', '\n'.join([load, run, mock]  )]

								# should succeed
								_snake_case   						=		self.get_env()
								# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
								_snake_case   						=		'1'
								_snake_case   						=		subprocess.run(lowerCAmelCase_    ,   env=lowerCAmelCase_    ,   check=lowerCAmelCase_    ,   capture_output=lowerCAmelCase_  )
								self.assertEqual(result.returncode    ,   0    ,   result.stderr  )
								self.assertIn('success'    ,   result.stdout.decode()  )


							@require_torch
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

								_snake_case   						=		'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

								_snake_case   						=		'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")\nsocket.socket = offline_socket\n        '

								# Force fetching the files so that we can use the cache
								_snake_case   						=		'hf-internal-testing/tiny-random-bert'
								BertConfig.from_pretrained(lowerCAmelCase_  )
								BertModel.from_pretrained(lowerCAmelCase_  )
								BertTokenizer.from_pretrained(lowerCAmelCase_  )
								pipeline(task='fill-mask'    ,   model=lowerCAmelCase_  )

								# baseline - just load from_pretrained with normal network
								_snake_case   						=		[sys.executable, '-c', '\n'.join([load, run, mock]  )]

								# should succeed
								_snake_case   						=		self.get_env()
								_snake_case   						=		subprocess.run(lowerCAmelCase_    ,   env=lowerCAmelCase_    ,   check=lowerCAmelCase_    ,   capture_output=lowerCAmelCase_  )
								self.assertEqual(result.returncode    ,   0    ,   result.stderr  )
								self.assertIn('success'    ,   result.stdout.decode()  )


							@require_torch
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		'\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

								_snake_case   						=		'\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n        '

								_snake_case   						=		'\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")\nsocket.socket = offline_socket\n        '

								# baseline - just load from_pretrained with normal network
								_snake_case   						=		[sys.executable, '-c', '\n'.join([load, run]  )]

								# should succeed
								_snake_case   						=		self.get_env()
								_snake_case   						=		subprocess.run(lowerCAmelCase_    ,   env=lowerCAmelCase_    ,   check=lowerCAmelCase_    ,   capture_output=lowerCAmelCase_  )
								self.assertEqual(result.returncode    ,   0    ,   result.stderr  )
								self.assertIn('success'    ,   result.stdout.decode()  )

								# next emulate no network
								_snake_case   						=		[sys.executable, '-c', '\n'.join([load, mock, run]  )]

								# Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
								# env["TRANSFORMERS_OFFLINE"] = "0"
								# result = subprocess.run(cmd, env=env, check=False, capture_output=True)
								# self.assertEqual(result.returncode, 1, result.stderr)

								# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
								_snake_case   						=		'1'
								_snake_case   						=		subprocess.run(lowerCAmelCase_    ,   env=lowerCAmelCase_    ,   check=lowerCAmelCase_    ,   capture_output=lowerCAmelCase_  )
								self.assertEqual(result.returncode    ,   0    ,   result.stderr  )
								self.assertIn('success'    ,   result.stdout.decode()  )


							@require_torch
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		'\nfrom transformers import pipeline\n        '
								_snake_case   						=		'\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n        '

								_snake_case   						=		'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n        '
								_snake_case   						=		self.get_env()
								_snake_case   						=		'1'
								_snake_case   						=		[sys.executable, '-c', '\n'.join([load, mock, run]  )]
								_snake_case   						=		subprocess.run(lowerCAmelCase_    ,   env=lowerCAmelCase_    ,   check=lowerCAmelCase_    ,   capture_output=lowerCAmelCase_  )
								self.assertEqual(result.returncode    ,   1    ,   result.stderr  )
								self.assertIn(
								    'You cannot infer task automatically within `pipeline` when using offline mode'    ,   result.stderr.decode().replace('\n'    ,   ''  )    ,   )




							@require_torch
							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								_snake_case   						=		'\nfrom transformers import AutoModel\n        '
								_snake_case   						=		'\nmname = "hf-internal-testing/test_dynamic_model"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint("success")\n        '

								# baseline - just load from_pretrained with normal network
								_snake_case   						=		[sys.executable, '-c', '\n'.join([load, run]  )]

								# should succeed
								_snake_case   						=		self.get_env()
								_snake_case   						=		subprocess.run(lowerCAmelCase_    ,   env=lowerCAmelCase_    ,   check=lowerCAmelCase_    ,   capture_output=lowerCAmelCase_  )
								self.assertEqual(result.returncode    ,   0    ,   result.stderr  )
								self.assertIn('success'    ,   result.stdout.decode()  )

								# should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
								_snake_case   						=		'1'
								_snake_case   						=		subprocess.run(lowerCAmelCase_    ,   env=lowerCAmelCase_    ,   check=lowerCAmelCase_    ,   capture_output=lowerCAmelCase_  )
								self.assertEqual(result.returncode    ,   0    ,   result.stderr  )
								self.assertIn('success'    ,   result.stdout.decode()  )

