
"""simple docstring"""

import shutil

import requests
def 		UpperCAmelCase					(		a_,						a_ = False,						a_ = "."			):





		'''simple docstring'''


		lowerCamelCase     :			int		=    'https://api.nasa.gov/planetary/apod'
		return requests.get(a_,						params={'api_key': api_key}			).json()
def 		UpperCAmelCase					(		a_,						a_ = "."			):





		'''simple docstring'''


		lowerCamelCase     :			List[Any]		=    get_apod_data(a_			)
		lowerCamelCase     :			List[str]		=    apod_data['url']
		lowerCamelCase     :			str		=    img_url.split('/'			)[-1]
		lowerCamelCase     :			Optional[Any]		=    requests.get(a_,						stream=a_			)

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





		'''simple docstring'''


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


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














import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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 transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
					from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import PoolFormerImageProcessor


class 			__SCREAMING_SNAKE_CASE    (      __lowercase):






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.config_class(**self.inputs_dict      )
												self.parent.assertTrue(hasattr(_UpperCamelCase   ,  'hidden_sizes'      )      )
												self.parent.assertTrue(hasattr(_UpperCamelCase   ,  'num_encoder_blocks'      )      )




class 			__SCREAMING_SNAKE_CASE    :






						def __init__(		self   ,  _UpperCamelCase   ,  _UpperCamelCase=13   ,  _UpperCamelCase=64   ,  _UpperCamelCase=3   ,  _UpperCamelCase=4   ,  _UpperCamelCase=[2, 2, 2, 2]   ,  _UpperCamelCase=[8, 4, 2, 1]   ,  _UpperCamelCase=[16, 32, 64, 1_28]   ,  _UpperCamelCase=[1, 4, 8, 16]   ,  _UpperCamelCase=False   ,  _UpperCamelCase=True   ,  _UpperCamelCase="gelu"   ,  _UpperCamelCase=0.1   ,  _UpperCamelCase=0.02   ,  _UpperCamelCase=3   ,  _UpperCamelCase=None   ,  ):






												"""simple docstring"""
												lowerCAmelCase__			  =  parent
												lowerCAmelCase__			  =  batch_size
												lowerCAmelCase__			  =  image_size
												lowerCAmelCase__			  =  num_channels
												lowerCAmelCase__			  =  num_encoder_blocks
												lowerCAmelCase__			  =  sr_ratios
												lowerCAmelCase__			  =  depths
												lowerCAmelCase__			  =  hidden_sizes
												lowerCAmelCase__			  =  downsampling_rates
												lowerCAmelCase__			  =  is_training
												lowerCAmelCase__			  =  use_labels
												lowerCAmelCase__			  =  hidden_act
												lowerCAmelCase__			  =  hidden_dropout_prob
												lowerCAmelCase__			  =  initializer_range
												lowerCAmelCase__			  =  num_labels
												lowerCAmelCase__			  =  scope






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												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.image_size, self.image_size]   ,  self.num_labels      )

												lowerCAmelCase__			  =  PoolFormerConfig(
												    image_size=self.image_size   ,  num_channels=self.num_channels   ,  num_encoder_blocks=self.num_encoder_blocks   ,  depths=self.depths   ,  hidden_sizes=self.hidden_sizes   ,  hidden_act=self.hidden_act   ,  hidden_dropout_prob=self.hidden_dropout_prob   ,  initializer_range=self.initializer_range   ,  )

												return config, pixel_values, labels






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  PoolFormerModel(config=_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()
												lowerCAmelCase__			  =  model(_UpperCamelCase      )
												lowerCAmelCase__			  =  lowerCAmelCase__			  =  self.image_size // 32.0
												self.parent.assertEqual(
												    result.last_hidden_state.shape   ,  (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)      )







						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.prepare_config_and_inputs()
												lowerCAmelCase__  ,				lowerCAmelCase__  ,				lowerCAmelCase__			  =  config_and_inputs
												lowerCAmelCase__			  =  {'pixel_values': pixel_values}
												return config, inputs_dict




@require_torch
class 			__SCREAMING_SNAKE_CASE    (      __lowercase						,    __lowercase						,    unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:				List[Any]            =    (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
						_SCREAMING_SNAKE_CASE		:				Optional[int]            =    (
						    {'''feature-extraction''': PoolFormerModel, '''image-classification''': PoolFormerForImageClassification}
						    if is_torch_available()
						    else {}
						)

						_SCREAMING_SNAKE_CASE		:				List[str]            =    False
						_SCREAMING_SNAKE_CASE		:				Optional[int]            =    False
						_SCREAMING_SNAKE_CASE		:				Optional[Any]            =    False
						_SCREAMING_SNAKE_CASE		:				str            =    False
						_SCREAMING_SNAKE_CASE		:				List[Any]            =    False






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  PoolFormerModelTester(self      )
												lowerCAmelCase__			  =  PoolFormerConfigTester(self   ,  config_class=_UpperCamelCase      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												self.config_tester.run_common_tests()






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_UpperCamelCase      )






						@unittest.skip('PoolFormer does not use inputs_embeds'      )
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												pass






						@unittest.skip('PoolFormer does not have get_input_embeddings method and get_output_embeddings methods'      )
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												pass






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												def check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      ):
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.eval()

																		with torch.no_grad():
																								lowerCAmelCase__			  =  model(**self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase      )      )

																		lowerCAmelCase__			  =  outputs.hidden_states

																		lowerCAmelCase__			  =  self.model_tester.num_encoder_blocks
																		self.assertEqual(len(_UpperCamelCase      )   ,  _UpperCamelCase      )

																		# verify the first hidden states (first block)
																		self.assertListEqual(
																		    list(hidden_states[0].shape[-3:]      )   ,  [
																		        self.model_tester.hidden_sizes[0],
																		        self.model_tester.image_size // 4,
																		        self.model_tester.image_size // 4,
																		    ]   ,  )

												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		lowerCAmelCase__			  =  True
																		check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      )

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

																		check_hidden_states_output(_UpperCamelCase   ,  _UpperCamelCase   ,  _UpperCamelCase      )






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												if not self.model_tester.is_training:
																		return

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

												for model_class in self.all_model_classes:
																		if model_class in get_values(_UpperCamelCase      ):
																								continue
																		lowerCAmelCase__			  =  model_class(_UpperCamelCase      )
																		model.to(_UpperCamelCase      )
																		model.train()
																		lowerCAmelCase__			  =  self._prepare_for_class(_UpperCamelCase   ,  _UpperCamelCase   ,  return_labels=_UpperCamelCase      )
																		lowerCAmelCase__			  =  model(**_UpperCamelCase      ).loss
																		loss.backward()






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__  ,				lowerCAmelCase__			  =  self.model_tester.prepare_config_and_inputs_for_common()

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

																		lowerCAmelCase__			  =  ['pixel_values']
																		self.assertListEqual(arg_names[:1]   ,  _UpperCamelCase      )







						@slow
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__			  =  PoolFormerModel.from_pretrained(_UpperCamelCase      )
																		self.assertIsNotNone(_UpperCamelCase      )







def 		_UpperCamelCase      (			)     ->      Optional[int]:

						"""simple docstring"""



						lowerCAmelCase__			  =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
						return image


@require_torch
class 			__SCREAMING_SNAKE_CASE    (      unittest.TestCase):






						@slow
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  PoolFormerImageProcessor()
												lowerCAmelCase__			  =  PoolFormerForImageClassification.from_pretrained('sail/poolformer_s12'      ).to(_UpperCamelCase      )

												lowerCAmelCase__			  =  image_processor(images=prepare_img()   ,  return_tensors='pt'      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																		lowerCAmelCase__			  =  model(**_UpperCamelCase      )

												# verify the logits
												lowerCAmelCase__			  =  torch.Size((1, 10_00)      )
												self.assertEqual(outputs.logits.shape   ,  _UpperCamelCase      )

												lowerCAmelCase__			  =  torch.tensor([-0.61_13, 0.16_85, -0.04_92]      ).to(_UpperCamelCase      )
												self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,  _UpperCamelCase   ,  atol=1E-4      )      )





