
import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, 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_FOR_IMAGE_CLASSIFICATION_MAPPING,
			    MODEL_MAPPING,
			    LevitForImageClassification,
			    LevitForImageClassificationWithTeacher,
			    LevitModel,
			)
			from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import LevitImageProcessor




class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase ):





	'''simple docstring'''



	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				_snake_case          =      self.config_class(**self.inputs_dict     )
				self.parent.assertTrue(hasattr(lowercase      ,  'hidden_sizes'     )     )
				self.parent.assertTrue(hasattr(lowercase      ,  'num_attention_heads'     )     )




class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	def __init__(  self     :   Union[str, Any]      ,  lowercase     :   List[str]      ,  lowercase     :   List[str]=13      ,  lowercase     :   Optional[Any]=64      ,  lowercase     :   int=3      ,  lowercase     :   int=3      ,  lowercase     :   Tuple=2      ,  lowercase     :   Tuple=1      ,  lowercase     :   Dict=16      ,  lowercase     :   str=[128, 256, 384]      ,  lowercase     :   List[Any]=[4, 6, 8]      ,  lowercase     :   Optional[Any]=[2, 3, 4]      ,  lowercase     :   str=[16, 16, 16]      ,  lowercase     :   str=0      ,  lowercase     :   Optional[int]=[2, 2, 2]      ,  lowercase     :   Optional[Any]=[2, 2, 2]      ,  lowercase     :   Union[str, Any]=0.02      ,  lowercase     :   Union[str, Any]=True      ,  lowercase     :   List[str]=True      ,  lowercase     :   List[str]=2      ,  ):


				'''simple docstring'''


				_snake_case          =      parent
				_snake_case          =      batch_size
				_snake_case          =      image_size
				_snake_case          =      num_channels
				_snake_case          =      kernel_size
				_snake_case          =      stride
				_snake_case          =      padding
				_snake_case          =      hidden_sizes
				_snake_case          =      num_attention_heads
				_snake_case          =      depths
				_snake_case          =      key_dim
				_snake_case          =      drop_path_rate
				_snake_case          =      patch_size
				_snake_case          =      attention_ratio
				_snake_case          =      mlp_ratio
				_snake_case          =      initializer_range
				_snake_case          =      [
				    ['Subsample', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
				    ['Subsample', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
				]
				_snake_case          =      is_training
				_snake_case          =      use_labels
				_snake_case          =      num_labels
				_snake_case          =      initializer_range



	def 			A							(  self     :   Optional[int]     ):


				'''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.num_labels     )

				_snake_case          =      self.get_config()
				return config, pixel_values, labels



	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				return LevitConfig(
				    image_size=self.image_size      ,  num_channels=self.num_channels      ,  kernel_size=self.kernel_size      ,  stride=self.stride      ,  padding=self.padding      ,  patch_size=self.patch_size      ,  hidden_sizes=self.hidden_sizes      ,  num_attention_heads=self.num_attention_heads      ,  depths=self.depths      ,  key_dim=self.key_dim      ,  drop_path_rate=self.drop_path_rate      ,  mlp_ratio=self.mlp_ratio      ,  attention_ratio=self.attention_ratio      ,  initializer_range=self.initializer_range      ,  down_ops=self.down_ops      ,  )



	def 			A							(  self     :   Tuple      ,  lowercase     :   Dict      ,  lowercase     :   Tuple      ,  lowercase     :   List[Any]     ):


				'''simple docstring'''


				_snake_case          =      LevitModel(config=lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase     )
				_snake_case          =      (self.image_size, self.image_size)
				_snake_case     , _snake_case          =      image_size[0], image_size[1]
				for _ in range(4     ):
							_snake_case          =      floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1     )
							_snake_case          =      floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1     )
				self.parent.assertEqual(
				    result.last_hidden_state.shape      ,  (self.batch_size, ceil(height / 4     ) * ceil(width / 4     ), self.hidden_sizes[-1])      ,  )



	def 			A							(  self     :   Any      ,  lowercase     :   Any      ,  lowercase     :   Optional[int]      ,  lowercase     :   Dict     ):


				'''simple docstring'''


				_snake_case          =      self.num_labels
				_snake_case          =      LevitForImageClassification(lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase      ,  labels=lowercase     )
				self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_labels)     )





	def 			A							(  self     :   Union[str, Any]     ):


				'''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        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase							,UpperCAmelCase							,unittest.TestCase ):





	'''simple docstring'''



	_UpperCAmelCase	:		Dict          = (
	    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
	    if is_torch_available()
	    else ()
	)
	_UpperCAmelCase	:		str          = (
	    {
	        "feature-extraction": LevitModel,
	        "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
	    }
	    if is_torch_available()
	    else {}
	)

	_UpperCAmelCase	:		Union[str, Any]          = False
	_UpperCAmelCase	:		str          = False
	_UpperCAmelCase	:		Tuple          = False
	_UpperCAmelCase	:		Union[str, Any]          = False
	_UpperCAmelCase	:		Optional[int]          = False



	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_snake_case          =      LevitModelTester(self     )
				_snake_case          =      ConfigTester(self      ,  config_class=lowercase      ,  has_text_modality=lowercase      ,  hidden_size=37     )



	def 			A							(  self     :   Optional[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 			A							(  self     :   List[Any]     ):


				'''simple docstring'''


				return



	@unittest.skip(reason='Levit does not use inputs_embeds'     )
	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				pass



	@unittest.skip(reason='Levit does not support input and output embeddings'     )
	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				pass



	@unittest.skip(reason='Levit does not output attentions'     )
	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				pass



	def 			A							(  self     :   Any     ):


				'''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(lowercase     )
							_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]      ,  lowercase     )



	def 			A							(  self     :   str     ):


				'''simple docstring'''


				def check_hidden_states_output(lowercase     :   List[Any]      ,  lowercase     :   Dict      ,  lowercase     :   int     ):
							_snake_case          =      model_class(lowercase     )
							model.to(lowercase     )
							model.eval()

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

							_snake_case          =      outputs.hidden_states

							_snake_case          =      len(self.model_tester.depths     ) + 1
							self.assertEqual(len(lowercase     )      ,  lowercase     )

							_snake_case          =      (self.model_tester.image_size, self.model_tester.image_size)
							_snake_case     , _snake_case          =      image_size[0], image_size[1]
							for _ in range(4     ):
										_snake_case          =      floor(
										    (
										        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
										        / self.model_tester.stride
										    )
										    + 1     )
										_snake_case          =      floor(
										    (
										        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
										        / self.model_tester.stride
										    )
										    + 1     )
							# verify the first hidden states (first block)
							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]     )      ,  [
							        height * width,
							        self.model_tester.hidden_sizes[0],
							    ]      ,  )

				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							_snake_case          =      True
							check_hidden_states_output(lowercase      ,  lowercase      ,  lowercase     )

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

							check_hidden_states_output(lowercase      ,  lowercase      ,  lowercase     )



	@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'     )
	def 			A							(  self     :   List[Any]     ):


				'''simple docstring'''


				pass



	def 			A							(  self     :   Any      ,  lowercase     :   Optional[Any]      ,  lowercase     :   Tuple      ,  lowercase     :   List[Any]=False     ):


				'''simple docstring'''


				_snake_case          =      super()._prepare_for_class(lowercase      ,  lowercase      ,  return_labels=lowercase     )

				if return_labels:
							if model_class.__name__ == "LevitForImageClassificationWithTeacher":
										del inputs_dict["labels"]

				return inputs_dict



	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


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



	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				_snake_case          =      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowercase     )



	def 			A							(  self     :   Union[str, Any]     ):


				'''simple docstring'''


				if not self.model_tester.is_training:
							return

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

				for model_class in self.all_model_classes:
							# LevitForImageClassificationWithTeacher supports inference-only
							if (
							    model_class in get_values(lowercase     )
							    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
							):
										continue
							_snake_case          =      model_class(lowercase     )
							model.to(lowercase     )
							model.train()
							_snake_case          =      self._prepare_for_class(lowercase      ,  lowercase      ,  return_labels=lowercase     )
							_snake_case          =      model(**lowercase     ).loss
							loss.backward()



	def 			A							(  self     :   Union[str, Any]     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()
				if not self.model_tester.is_training:
							return

				_snake_case          =      False
				_snake_case          =      True

				for model_class in self.all_model_classes:
							if model_class in get_values(lowercase     ) or not model_class.supports_gradient_checkpointing:
										continue
							# LevitForImageClassificationWithTeacher supports inference-only
							if model_class.__name__ == "LevitForImageClassificationWithTeacher":
										continue
							_snake_case          =      model_class(lowercase     )
							model.gradient_checkpointing_enable()
							model.to(lowercase     )
							model.train()
							_snake_case          =      self._prepare_for_class(lowercase      ,  lowercase      ,  return_labels=lowercase     )
							_snake_case          =      model(**lowercase     ).loss
							loss.backward()



	def 			A							(  self     :   Any     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()

				_snake_case          =      [
				    {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
				    {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
				    {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
				]

				for model_class in self.all_model_classes:
							if (
							    model_class
							    not in [
							        *get_values(lowercase     ),
							    ]
							    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
							):
										continue

							for problem_type in problem_types:
										with self.subTest(msg=f'''Testing {model_class} with {problem_type['title']}'''     ):
													_snake_case          =      problem_type['title']
													_snake_case          =      problem_type['num_labels']

													_snake_case          =      model_class(lowercase     )
													model.to(lowercase     )
													model.train()

													_snake_case          =      self._prepare_for_class(lowercase      ,  lowercase      ,  return_labels=lowercase     )

													if problem_type["num_labels"] > 1:
																_snake_case          =      inputs['labels'].unsqueeze(1     ).repeat(1      ,  problem_type['num_labels']     )

													_snake_case          =      inputs['labels'].to(problem_type['dtype']     )

													# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
													# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
													# they have the same size." which is a symptom something in wrong for the regression problem.
													# See https://github.com/huggingface/transformers/issues/11780
													with warnings.catch_warnings(record=lowercase     ) as warning_list:
																_snake_case          =      model(**lowercase     ).loss
													for w in warning_list:
																if "Using a target size that is different to the input size" in str(w.message     ):
																			raise ValueError(
																			    f'''Something is going wrong in the regression problem: intercepted {w.message}'''     )

													loss.backward()





	@slow
	def 			A							(  self     :   str     ):


				'''simple docstring'''


				for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							_snake_case          =      LevitModel.from_pretrained(lowercase     )
							self.assertIsNotNone(lowercase     )






def 	a_		(	)			->  int:
			_snake_case          =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
			return image




@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE__					(     unittest.TestCase ):





	'''simple docstring'''



	@cached_property
	def 			A							(  self     :   Union[str, Any]     ):


				'''simple docstring'''


				return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )





	@slow
	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				_snake_case          =      LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(
				    lowercase     )

				_snake_case          =      self.default_image_processor
				_snake_case          =      prepare_img()
				_snake_case          =      image_processor(images=lowercase      ,  return_tensors='pt'     ).to(lowercase     )

				# forward pass
				with torch.no_grad():
							_snake_case          =      model(**lowercase     )

				# verify the logits
				_snake_case          =      torch.Size((1, 1_000)     )
				self.assertEqual(outputs.logits.shape      ,  lowercase     )

				_snake_case          =      torch.tensor([1.0448, -0.3745, -1.8317]     ).to(lowercase     )

				self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,  lowercase      ,  atol=1E-4     )     )

from __future__ import annotations

import requests

_lowerCamelCase	:    List[str]          =      set(
    '''approved_at_utc approved_by author_flair_background_color
author_flair_css_class author_flair_richtext author_flair_template_id author_fullname
author_premium can_mod_post category clicked content_categories created_utc downs
edited gilded gildings hidden hide_score is_created_from_ads_ui is_meta
is_original_content is_reddit_media_domain is_video link_flair_css_class
link_flair_richtext link_flair_text link_flair_text_color media_embed mod_reason_title
name permalink pwls quarantine saved score secure_media secure_media_embed selftext
subreddit subreddit_name_prefixed subreddit_type thumbnail title top_awarded_type
total_awards_received ups upvote_ratio url user_reports'''.split()
)






def 	a_		(	__lowercase       :     str	, __lowercase       :     int = 1	, __lowercase       :     str = "new"	, __lowercase       :     list | None = None			)			->  dict:
			_snake_case          =      wanted_data or []
			if invalid_search_terms := ", ".join(sorted(set(__lowercase			) - valid_terms			)			):
						_snake_case          =      f'''Invalid search term: {invalid_search_terms}'''
						raise ValueError(__lowercase			)
			_snake_case          =      requests.get(
			    f'''https://reddit.com/r/{subreddit}/{age}.json?limit={limit}'''	, headers={'User-agent': 'A random string'}	, )
			if response.status_code == 429:
						raise requests.HTTPError

			_snake_case          =      response.json()
			if not wanted_data:
						return {id_: data["data"]["children"][id_] for id_ in range(__lowercase			)}

			_snake_case          =      {}
			for id_ in range(__lowercase			):
						_snake_case          =      {
						    item: data['data']['children'][id_]['data'][item] for item in wanted_data
						}
			return data_dict


if __name__ == "__main__":
			# If you get Error 429, that means you are rate limited.Try after some time
			print(get_subreddit_data('''learnpython''', wanted_data=['''title''', '''url''', '''selftext''']))