


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_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


if is_torch_available():
	import torch

	from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin



class 			lowerCamelCase__						:







						def __init__(							self   :    Any			,			_lowercase   :    Tuple			,			_lowercase   :    Optional[int]=None			,			_lowercase   :    Optional[Any]=None			,			_lowercase   :    str=None			,			_lowercase   :    Optional[Any]="resnet50"			,			_lowercase   :    Any=3			,			_lowercase   :    str=32			,			_lowercase   :    str=3			,			_lowercase   :    Optional[int]=True			,			_lowercase   :    Union[str, Any]=True			,			):
								A					       = parent
								A					       = out_indices if out_indices is not None else [4]
								A					       = stage_names
								A					       = out_features
								A					       = backbone
								A					       = batch_size
								A					       = image_size
								A					       = num_channels
								A					       = use_pretrained_backbone
								A					       = is_training







						def __a						(							self   :    Union[str, Any]		):
								A					       = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)
								A					       = self.get_config()

								return config, pixel_values







						def __a						(							self   :    Optional[int]		):
								return TimmBackboneConfig(
								    image_size=self.image_size			,			num_channels=self.num_channels			,			out_features=self.out_features			,			out_indices=self.out_indices			,			stage_names=self.stage_names			,			use_pretrained_backbone=self.use_pretrained_backbone			,			backbone=self.backbone			,			)







						def __a						(							self   :    Tuple			,			_lowercase   :    Any			,			_lowercase   :    int		):
								A					       = TimmBackbone(config=_A		)
								model.to(_A		)
								model.eval()
								with torch.no_grad():
										A					       = model(_A		)
								self.parent.assertEqual(
								    result.feature_map[-1].shape			,			(self.batch_size, model.channels[-1], 14, 14)			,			)







						def __a						(							self   :    int		):
								A					       = self.prepare_config_and_inputs()
								A       , A					       = config_and_inputs
								A					       = {'pixel_values': pixel_values}
								return config, inputs_dict



@require_torch
@require_timm
class 			lowerCamelCase__						(   _a							,    _a							,    _a							,    unittest.TestCase			):
						lowerCAmelCase       =     (TimmBackbone,) if is_torch_available() else ()
						lowerCAmelCase       =     {"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
						lowerCAmelCase       =     False
						lowerCAmelCase       =     False
						lowerCAmelCase       =     False
						lowerCAmelCase       =     False







						def __a						(							self   :    List[Any]		):
								A					       = TimmBackboneModelTester(self		)
								A					       = ConfigTester(self			,			config_class=_A			,			has_text_modality=_A		)







						def __a						(							self   :    Optional[Any]		):
								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 __a						(							self   :    Union[str, Any]		):
								A					       = 'resnet18'
								A					       = 'microsoft/resnet-18'

								A					       = AutoBackbone.from_pretrained(_A			,			use_timm_backbone=_A		)
								A					       = AutoBackbone.from_pretrained(_A		)

								self.assertEqual(len(timm_model.out_features		)			,			len(transformers_model.out_features		)		)
								self.assertEqual(len(timm_model.stage_names		)			,			len(transformers_model.stage_names		)		)
								self.assertEqual(timm_model.channels			,			transformers_model.channels		)
								# Out indices are set to the last layer by default. For timm models, we don't know
								# the number of layers in advance, so we set it to (-1,), whereas for transformers
								# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
								self.assertEqual(timm_model.out_indices			,			(-1,)		)
								self.assertEqual(transformers_model.out_indices			,			[len(timm_model.stage_names		) - 1]		)

								A					       = AutoBackbone.from_pretrained(_A			,			use_timm_backbone=_A			,			out_indices=[1, 2, 3]		)
								A					       = AutoBackbone.from_pretrained(_A			,			out_indices=[1, 2, 3]		)

								self.assertEqual(timm_model.out_indices			,			transformers_model.out_indices		)
								self.assertEqual(len(timm_model.out_features		)			,			len(transformers_model.out_features		)		)
								self.assertEqual(timm_model.channels			,			transformers_model.channels		)







						@unittest.skip('TimmBackbone doesn\'t support feed forward chunking'		)
						def __a						(							self   :    Optional[int]		):
								pass







						@unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'		)
						def __a						(							self   :    Tuple		):
								pass







						@unittest.skip('TimmBackbone initialization is managed on the timm side'		)
						def __a						(							self   :    Dict		):
								pass







						@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'		)
						def __a						(							self   :    Dict		):
								pass







						@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'		)
						def __a						(							self   :    Optional[int]		):
								pass







						@unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'		)
						def __a						(							self   :    List[Any]		):
								pass







						@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'		)
						def __a						(							self   :    Optional[Any]		):
								pass







						@unittest.skip('model weights aren\'t tied in TimmBackbone.'		)
						def __a						(							self   :    Optional[int]		):
								pass







						@unittest.skip('model weights aren\'t tied in TimmBackbone.'		)
						def __a						(							self   :    List[Any]		):
								pass







						@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'		)
						def __a						(							self   :    List[Any]		):
								pass







						@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'		)
						def __a						(							self   :    Optional[Any]		):
								pass







						@unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'		)
						def __a						(							self   :    List[str]		):
								pass







						@unittest.skip('TimmBackbone doesn\'t support output_attentions.'		)
						def __a						(							self   :    List[Any]		):
								pass







						@unittest.skip('Safetensors is not supported by timm.'		)
						def __a						(							self   :    List[Any]		):
								pass







						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'		)
						def __a						(							self   :    Union[str, Any]		):
								pass







						def __a						(							self   :    Dict		):
								A       , A					       = self.model_tester.prepare_config_and_inputs_for_common()

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

										A					       = ['pixel_values']
										self.assertListEqual(arg_names[:1]			,			_A		)







						def __a						(							self   :    str		):
								A       , A					       = self.model_tester.prepare_config_and_inputs_for_common()
								A					       = True
								A					       = self.has_attentions

								# no need to test all models as different heads yield the same functionality
								A					       = self.all_model_classes[0]
								A					       = model_class(_A		)
								model.to(_A		)

								A					       = self._prepare_for_class(_A			,			_A		)
								A					       = model(**_A		)
								A					       = outputs[0][-1]

								# Encoder-/Decoder-only models
								A					       = outputs.hidden_states[0]
								hidden_states.retain_grad()

								if self.has_attentions:
										A					       = outputs.attentions[0]
										attentions.retain_grad()

								output.flatten()[0].backward(retain_graph=_A		)

								self.assertIsNotNone(hidden_states.grad		)

								if self.has_attentions:
										self.assertIsNotNone(attentions.grad		)







						def __a						(							self   :    Any		):
								A       , A					       = self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										A					       = model_class(_A		)
										model.to(_A		)
										model.eval()
										A					       = model(**_A		)

										self.assertEqual(len(result.feature_maps		)			,			len(config.out_indices		)		)
										self.assertEqual(len(model.channels		)			,			len(config.out_indices		)		)

										# Check output of last stage is taken if out_features=None, out_indices=None
										A					       = copy.deepcopy(_A		)
										A					       = None
										A					       = model_class(_A		)
										model.to(_A		)
										model.eval()
										A					       = model(**_A		)

										self.assertEqual(len(result.feature_maps		)			,			1		)
										self.assertEqual(len(model.channels		)			,			1		)

										# Check backbone can be initialized with fresh weights
										A					       = copy.deepcopy(_A		)
										A					       = False
										A					       = model_class(_A		)
										model.to(_A		)
										model.eval()
										A					       = model(**_A		)









"""simple docstring"""


from unittest.mock import Mock, patch

from file_transfer.send_file import send_file







@patch('socket.socket'	)
@patch('builtins.open'	)
def  __snake_case       (   UpperCamelCase__ ,			UpperCamelCase__	)      ->		Dict:







		"""simple docstring"""





		A					       = Mock()
		A					       = conn, Mock()
		A					       = iter([1, None]	)
		A					       = lambda UpperCamelCase__	: next(UpperCamelCase__	)

		# ===== invoke =====
		send_file(filename='mytext.txt' ,			testing=UpperCamelCase__	)

		# ===== ensurance =====
		sock.assert_called_once()
		sock.return_value.bind.assert_called_once()
		sock.return_value.listen.assert_called_once()
		sock.return_value.accept.assert_called_once()
		conn.recv.assert_called_once()

		file.return_value.__enter__.assert_called_once()
		file.return_value.__enter__.return_value.read.assert_called()

		conn.send.assert_called_once()
		conn.close.assert_called_once()
		sock.return_value.shutdown.assert_called_once()
		sock.return_value.close.assert_called_once()





