





from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers.models.swin.modeling_tf_swin import (
	    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TFSwinForImageClassification,
	    TFSwinForMaskedImageModeling,
	    TFSwinModel,
	)


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor




class      UpperCamelCase_				:


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



									"""simple docstring"""



									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


							def    _snake_case     (							self			:Dict						)      ->      Optional[int]:



									"""simple docstring"""



									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    _snake_case     (							self			:List[Any]						)      ->      str:



									"""simple docstring"""



									return SwinConfig(
									    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							, )


							def    _snake_case     (							self			:Optional[Any]							, __A			:Union[str, Any]							, __A			:Union[str, Any]							, __A			:Optional[Any]						)      ->      Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					TFSwinModel(config=__A						)
									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    _snake_case     (							self			:Tuple							, __A			:Tuple							, __A			:Optional[int]							, __A			:Tuple						)      ->      Union[str, Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					TFSwinForMaskedImageModeling(config=__A						)
									SCREAMING_SNAKE_CASE__								=					model(__A						)
									self.parent.assertEqual(
									    result.logits.shape							, (self.batch_size, self.num_channels, self.image_size, self.image_size)						)

									# test greyscale images
									SCREAMING_SNAKE_CASE__								=					1
									SCREAMING_SNAKE_CASE__								=					TFSwinForMaskedImageModeling(__A						)

									SCREAMING_SNAKE_CASE__								=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
									SCREAMING_SNAKE_CASE__								=					model(__A						)
									self.parent.assertEqual(result.logits.shape							, (self.batch_size, 1, self.image_size, self.image_size)						)


							def    _snake_case     (							self			:Optional[Any]							, __A			:Any							, __A			:int							, __A			:Optional[Any]						)      ->      Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.type_sequence_label_size
									SCREAMING_SNAKE_CASE__								=					TFSwinForImageClassification(__A						)
									SCREAMING_SNAKE_CASE__								=					model(__A							, labels=__A						)
									self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.type_sequence_label_size)						)

									# test greyscale images
									SCREAMING_SNAKE_CASE__								=					1
									SCREAMING_SNAKE_CASE__								=					TFSwinForImageClassification(__A						)
									SCREAMING_SNAKE_CASE__								=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
									SCREAMING_SNAKE_CASE__								=					model(__A						)
									self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.type_sequence_label_size)						)


							def    _snake_case     (							self			:List[Any]						)      ->      Optional[Any]:



									"""simple docstring"""



									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_tf
class      UpperCamelCase_				(   UpperCamelCase__ ,     UpperCamelCase__ ,     unittest.TestCase			):
							lowerCamelCase_							=    (
							    (
							        TFSwinModel,
							        TFSwinForImageClassification,
							        TFSwinForMaskedImageModeling,
							    )
							    if is_tf_available()
							    else ()
							)
							lowerCamelCase_							=    (
							    {"feature-extraction": TFSwinModel, "image-classification": TFSwinForImageClassification}
							    if is_tf_available()
							    else {}
							)

							lowerCamelCase_							=    False
							lowerCamelCase_							=    False
							lowerCamelCase_							=    False
							lowerCamelCase_							=    False


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					TFSwinModelTester(self						)
									SCREAMING_SNAKE_CASE__								=					ConfigTester(self							, config_class=__A							, embed_dim=37						)


							def    _snake_case     (							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    _snake_case     (							self			:Union[str, Any]						)      ->      List[str]:



									"""simple docstring"""



									return


							def    _snake_case     (							self			:Optional[Any]						)      ->      Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__A						)


							def    _snake_case     (							self			:List[Any]						)      ->      int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*__A						)


							def    _snake_case     (							self			:int						)      ->      Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__A						)


							@unittest.skip(reason="""Swin does not use inputs_embeds"""						)
							def    _snake_case     (							self			:Optional[Any]						)      ->      Tuple:



									"""simple docstring"""



									pass


							def    _snake_case     (							self			:int						)      ->      Optional[int]:



									"""simple docstring"""



									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()							, tf.keras.layers.Layer						)
											SCREAMING_SNAKE_CASE__								=					model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(__A							, tf.keras.layers.Dense						)						)


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



									"""simple docstring"""



									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.call						)
											# 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						)


							def    _snake_case     (							self			:Tuple						)      ->      Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs_for_common()
									SCREAMING_SNAKE_CASE__								=					True

									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE__								=					True
											SCREAMING_SNAKE_CASE__								=					False
											SCREAMING_SNAKE_CASE__								=					True
											SCREAMING_SNAKE_CASE__								=					model_class(__A						)
											SCREAMING_SNAKE_CASE__								=					model(**self._prepare_for_class(__A							, __A						)						)
											SCREAMING_SNAKE_CASE__								=					outputs.attentions
											SCREAMING_SNAKE_CASE__								=					len(self.model_tester.depths						)
											self.assertEqual(len(__A						)							, __A						)

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											SCREAMING_SNAKE_CASE__								=					True
											SCREAMING_SNAKE_CASE__								=					config.window_size**2
											SCREAMING_SNAKE_CASE__								=					model_class(__A						)
											SCREAMING_SNAKE_CASE__								=					model(**self._prepare_for_class(__A							, __A						)						)
											SCREAMING_SNAKE_CASE__								=					outputs.attentions
											self.assertEqual(len(__A						)							, __A						)

											self.assertListEqual(
											    list(attentions[0].shape[-3:]						)							, [self.model_tester.num_heads[0], window_size_squared, window_size_squared]							, )
											SCREAMING_SNAKE_CASE__								=					len(__A						)

											# Check attention is always last and order is fine
											SCREAMING_SNAKE_CASE__								=					True
											SCREAMING_SNAKE_CASE__								=					True
											SCREAMING_SNAKE_CASE__								=					model_class(__A						)
											SCREAMING_SNAKE_CASE__								=					model(**self._prepare_for_class(__A							, __A						)						)

											if hasattr(self.model_tester							, """num_hidden_states_types"""						):
													SCREAMING_SNAKE_CASE__								=					self.model_tester.num_hidden_states_types
											else:
													# also another +1 for reshaped_hidden_states
													SCREAMING_SNAKE_CASE__								=					2
											self.assertEqual(out_len + added_hidden_states							, len(__A						)						)

											SCREAMING_SNAKE_CASE__								=					outputs.attentions

											self.assertEqual(len(__A						)							, __A						)

											self.assertListEqual(
											    list(self_attentions[0].shape[-3:]						)							, [self.model_tester.num_heads[0], window_size_squared, window_size_squared]							, )


							def    _snake_case     (							self			:Optional[Any]							, __A			:str							, __A			:Any							, __A			:Union[str, Any]							, __A			:Optional[int]						)      ->      Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					model_class(__A						)
									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__								=					to_atuple(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]							, )

									SCREAMING_SNAKE_CASE__								=					outputs.reshaped_hidden_states
									self.assertEqual(len(__A						)							, __A						)

									SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					reshaped_hidden_states[0].shape

									SCREAMING_SNAKE_CASE__								=					tf.reshape(reshaped_hidden_states[0]							, (batch_size, num_channels, height * width)						)
									SCREAMING_SNAKE_CASE__								=					tf.transpose(__A							, (0, 2, 1)						)

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


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								=					self.model_tester.prepare_config_and_inputs_for_common()

									SCREAMING_SNAKE_CASE__								=					to_atuple(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    _snake_case     (							self			:List[str]						)      ->      Union[str, Any]:



									"""simple docstring"""



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

									SCREAMING_SNAKE_CASE__								=					to_atuple(self.model_tester.image_size						)
									SCREAMING_SNAKE_CASE__								=					to_atuple(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)						)


							@slow
							def    _snake_case     (							self			:Any						)      ->      Dict:



									"""simple docstring"""



									for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE__								=					TFSwinModel.from_pretrained(__A						)
											self.assertIsNotNone(__A						)




@require_vision
@require_tf
class      UpperCamelCase_				(   unittest.TestCase			):


							@cached_property
							def    _snake_case     (							self			:Any						)      ->      Any:



									"""simple docstring"""



									return (
									    AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""						)
									    if is_vision_available()
									    else None
									)


							@slow
							def    _snake_case     (							self			:Any						)      ->      Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					TFSwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""						)
									SCREAMING_SNAKE_CASE__								=					self.default_image_processor

									SCREAMING_SNAKE_CASE__								=					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
									SCREAMING_SNAKE_CASE__								=					image_processor(images=__A							, return_tensors="""tf"""						)

									# forward pass
									SCREAMING_SNAKE_CASE__								=					model(__A						)

									# verify the logits
									SCREAMING_SNAKE_CASE__								=					tf.TensorShape((1, 1000)						)
									self.assertEqual(outputs.logits.shape							, __A						)
									SCREAMING_SNAKE_CASE__								=					tf.constant([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]						)
									self.assertTrue(np.allclose(outputs.logits[0, :3]							, __A							, atol=1E-4						)						)






from datetime import date

import requests

_lowerCamelCase       =	'https://api.carbonintensity.org.uk/intensity'






def  SCREAMING_SNAKE_CASE__							(				):
		SCREAMING_SNAKE_CASE__								=					requests.get(UpperCamelCase__			).json()["""data"""][0]
		return last_half_hour["intensity"]["actual"]






def  SCREAMING_SNAKE_CASE__							(				UpperCamelCase__:							Dict    ,      UpperCamelCase__:							Optional[int]			):
		return requests.get(f'''{BASE_URL}/{start}/{end}'''			).json()["data"]


if __name__ == "__main__":
	for entry in fetch_from_to(start=date(2020, 10, 1), end=date(2020, 10, 3)):
		print('from {from} to {to}: {intensity[actual]}'.format(**entry))
	print(F'''{fetch_last_half_hour() = }''')