




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 			A			:
     """simple docstring"""

     def __init__(    self  :   List[Any]	,  A__  :   int	,  A__  :   Dict=1_3	,  A__  :   Dict=3_2	,  A__  :   Optional[Any]=2	,  A__  :   List[str]=3	,  A__  :   str=1_6	,  A__  :   List[Any]=[1, 2, 1]	,  A__  :   Optional[Any]=[2, 2, 4]	,  A__  :   Union[str, Any]=2	,  A__  :   List[Any]=2.0	,  A__  :   Optional[int]=True	,  A__  :   Tuple=0.0	,  A__  :   str=0.0	,  A__  :   Optional[Any]=0.1	,  A__  :   str="gelu"	,  A__  :   Optional[int]=False	,  A__  :   List[str]=True	,  A__  :   Union[str, Any]=0.02	,  A__  :   str=1E-5	,  A__  :   Any=True	,  A__  :   Tuple=None	,  A__  :   Optional[Any]=True	,  A__  :   Tuple=1_0	,  A__  :   Tuple=8	,  )				->       None:
           lowerCamelCase__        =				parent
           lowerCamelCase__        =				batch_size
           lowerCamelCase__        =				image_size
           lowerCamelCase__        =				patch_size
           lowerCamelCase__        =				num_channels
           lowerCamelCase__        =				embed_dim
           lowerCamelCase__        =				depths
           lowerCamelCase__        =				num_heads
           lowerCamelCase__        =				window_size
           lowerCamelCase__        =				mlp_ratio
           lowerCamelCase__        =				qkv_bias
           lowerCamelCase__        =				hidden_dropout_prob
           lowerCamelCase__        =				attention_probs_dropout_prob
           lowerCamelCase__        =				drop_path_rate
           lowerCamelCase__        =				hidden_act
           lowerCamelCase__        =				use_absolute_embeddings
           lowerCamelCase__        =				patch_norm
           lowerCamelCase__        =				layer_norm_eps
           lowerCamelCase__        =				initializer_range
           lowerCamelCase__        =				is_training
           lowerCamelCase__        =				scope
           lowerCamelCase__        =				use_labels
           lowerCamelCase__        =				type_sequence_label_size
           lowerCamelCase__        =				encoder_stride




     def  __snake_case   (    self  :   List[str]			)				->       int:
           lowerCamelCase__        =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

           lowerCamelCase__        =				self.get_config()

           return config, pixel_values, labels




     def  __snake_case   (    self  :   int			)				->       Optional[Any]:
           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  :   int	,  A__  :   Dict	,  A__  :   Optional[Any]	,  A__  :   List[str]			)				->       Optional[int]:
           lowerCamelCase__        =				TFSwinModel(config=A__			)
           lowerCamelCase__        =				model(A__			)

           lowerCamelCase__        =				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
           lowerCamelCase__        =				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  :   Union[str, Any]	,  A__  :   Union[str, Any]	,  A__  :   str	,  A__  :   Union[str, Any]			)				->       Dict:
           lowerCamelCase__        =				TFSwinForMaskedImageModeling(config=A__			)
           lowerCamelCase__        =				model(A__			)
           self.parent.assertEqual(
               result.logits.shape	,  (self.batch_size, self.num_channels, self.image_size, self.image_size)			)

           # test greyscale images
           lowerCamelCase__        =				1
           lowerCamelCase__        =				TFSwinForMaskedImageModeling(A__			)

           lowerCamelCase__        =				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
           lowerCamelCase__        =				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__  :   Tuple	,  A__  :   List[str]	,  A__  :   List[Any]			)				->       int:
           lowerCamelCase__        =				self.type_sequence_label_size
           lowerCamelCase__        =				TFSwinForImageClassification(A__			)
           lowerCamelCase__        =				model(A__	,  labels=A__			)
           self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.type_sequence_label_size)			)

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




     def  __snake_case   (    self  :   Any			)				->       str:
           lowerCamelCase__        =				self.prepare_config_and_inputs()
           lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__        =				config_and_inputs
           lowerCamelCase__        =				{'pixel_values': pixel_values}
           return config, inputs_dict






@require_tf
class 			A			(		_lowerCAmelCase			,						_lowerCAmelCase			,						unittest.TestCase		):
     """simple docstring"""

     _snake_case:	Union[str, Any]     =(
         (
             TFSwinModel,
             TFSwinForImageClassification,
             TFSwinForMaskedImageModeling,
         )
         if is_tf_available()
         else ()
     )
     _snake_case:	int     =(
         {"feature-extraction": TFSwinModel, "image-classification": TFSwinForImageClassification}
         if is_tf_available()
         else {}
     )

     _snake_case:	Optional[int]     =False
     _snake_case:	Any     =False
     _snake_case:	int     =False
     _snake_case:	int     =False




     def  __snake_case   (    self  :   Any			)				->       Optional[Any]:
           lowerCamelCase__        =				TFSwinModelTester(self			)
           lowerCamelCase__        =				ConfigTester(self	,  config_class=A__	,  embed_dim=3_7			)




     def  __snake_case   (    self  :   str			)				->       List[str]:
           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  :   Tuple			)				->       str:
           return




     def  __snake_case   (    self  :   List[str]			)				->       str:
           lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*A__			)




     def  __snake_case   (    self  :   List[Any]			)				->       Union[str, Any]:
           lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_image_modeling(*A__			)




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




     def  __snake_case   (    self  :   List[Any]			)				->       int:
           lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 lowerCamelCase__        =				model_class(A__			)
                 self.assertIsInstance(model.get_input_embeddings()	,  tf.keras.layers.Layer			)
                 lowerCamelCase__        =				model.get_output_embeddings()
                 self.assertTrue(x is None or isinstance(A__	,  tf.keras.layers.Dense			)			)




     def  __snake_case   (    self  :   List[Any]			)				->       List[Any]:
           lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs_for_common()

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

                 lowerCamelCase__        =				['pixel_values']
                 self.assertListEqual(arg_names[:1]	,  A__			)




     def  __snake_case   (    self  :   Optional[Any]			)				->       Optional[Any]:
           lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs_for_common()
           lowerCamelCase__        =				True

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

                 # check that output_attentions also work using config
                 del inputs_dict["output_attentions"]
                 lowerCamelCase__        =				True
                 lowerCamelCase__        =				config.window_size**2
                 lowerCamelCase__        =				model_class(A__			)
                 lowerCamelCase__        =				model(**self._prepare_for_class(A__	,  A__			)			)
                 lowerCamelCase__        =				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]	,  )
                 lowerCamelCase__        =				len(A__			)

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

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

                 lowerCamelCase__        =				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[int]	,  A__  :   Tuple	,  A__  :   Union[str, Any]	,  A__  :   str	,  A__  :   str			)				->       List[Any]:
           lowerCamelCase__        =				model_class(A__			)
           lowerCamelCase__        =				model(**self._prepare_for_class(A__	,  A__			)			)
           lowerCamelCase__        =				outputs.hidden_states

           lowerCamelCase__        =				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
           lowerCamelCase__        =				to_atuple(config.patch_size			)

           lowerCamelCase__        =				(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]	,  )

           lowerCamelCase__        =				outputs.reshaped_hidden_states
           self.assertEqual(len(A__			)	,  A__			)

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

           lowerCamelCase__        =				tf.reshape(reshaped_hidden_states[0]	,  (batch_size, num_channels, height * width)			)
           lowerCamelCase__        =				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  :   Any			)				->       Optional[int]:
           lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs_for_common()

           lowerCamelCase__        =				to_atuple(self.model_tester.image_size			)

           for model_class in self.all_model_classes:
                 lowerCamelCase__        =				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"]
                 lowerCamelCase__        =				True

                 self.check_hidden_states_output(A__	,  A__	,  A__	,  A__			)




     def  __snake_case   (    self  :   List[Any]			)				->       str:
           lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs_for_common()
           lowerCamelCase__        =				3

           lowerCamelCase__        =				to_atuple(self.model_tester.image_size			)
           lowerCamelCase__        =				to_atuple(config.patch_size			)

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

           for model_class in self.all_model_classes:
                 lowerCamelCase__        =				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"]
                 lowerCamelCase__        =				True
                 self.check_hidden_states_output(A__	,  A__	,  A__	,  (padded_height, padded_width)			)




     @slow
     def  __snake_case   (    self  :   Dict			)				->       Optional[int]:
           for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCamelCase__        =				TFSwinModel.from_pretrained(A__			)
                 self.assertIsNotNone(A__			)






@require_vision
@require_tf
class 			A			(		unittest.TestCase		):
     """simple docstring"""

     @cached_property
     def  __snake_case   (    self  :   List[str]			)				->       Tuple:
           return (
               AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'			)
               if is_vision_available()
               else None
           )




     @slow
     def  __snake_case   (    self  :   Optional[Any]			)				->       Union[str, Any]:
           lowerCamelCase__        =				TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'			)
           lowerCamelCase__        =				self.default_image_processor

           lowerCamelCase__        =				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
           lowerCamelCase__        =				image_processor(images=A__	,  return_tensors='tf'			)

           # forward pass
           lowerCamelCase__        =				model(A__			)

           # verify the logits
           lowerCamelCase__        =				tf.TensorShape((1, 1_0_0_0)			)
           self.assertEqual(outputs.logits.shape	,  A__			)
           lowerCamelCase__        =				tf.constant([-0.0948, -0.6454, -0.0921]			)
           self.assertTrue(np.allclose(outputs.logits[0, :3]	,  A__	,  atol=1E-4			)			)





import shutil

import requests

def 			lowerCAmelCase_			(  lowerCamelCase:       str     ,				lowerCamelCase:       bool = False     ,				lowerCamelCase:       str = "."						)					->			dict:


      '''simple docstring'''




      lowerCamelCase__        =				'https://api.nasa.gov/planetary/apod'
      return requests.get(lowerCamelCase     ,				params={'api_key': api_key}						).json()

def 			lowerCAmelCase_			(  lowerCamelCase:       str     ,				lowerCamelCase:       str = "."						)					->			dict:


      '''simple docstring'''




      lowerCamelCase__        =				get_apod_data(lowerCamelCase						)
      lowerCamelCase__        =				apod_data['url']
      lowerCamelCase__        =				img_url.split('/'						)[-1]
      lowerCamelCase__        =				requests.get(lowerCamelCase     ,				stream=lowerCamelCase						)

      with open(f"""{path}/{img_name}"""     ,				'wb+'						) as img_file:
            shutil.copyfileobj(response.raw     ,				lowerCamelCase						)
      del response
      return apod_data

def 			lowerCAmelCase_			(  lowerCamelCase:       str						)					->			dict:


      '''simple docstring'''




      lowerCamelCase__        =				'https://images-api.nasa.gov/search'
      return requests.get(lowerCamelCase     ,				params={'q': query}						).json()


if __name__ == "__main__":
      print(save_apod("""YOUR API KEY"""))
      __SCREAMING_SNAKE_CASE    :   Tuple       =get_archive_data("""apollo 2011""")["""collection"""]["""items"""]
      print(apollo_aaaa_items[0]["""data"""][0]["""description"""])