


from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
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 import TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor







class 				snake_case__:







						'''simple docstring'''




						def __init__(				self   ,						__lowercase   ,						__lowercase=3   ,						__lowercase=3_2   ,						__lowercase=3   ,						__lowercase=1_0   ,						__lowercase=[1_0, 2_0, 3_0, 4_0]   ,						__lowercase=[1, 1, 2, 1]   ,						__lowercase=True   ,						__lowercase=True   ,						__lowercase="relu"   ,						__lowercase=3   ,						__lowercase=None   ,						)					->    int:
										lowerCAmelCase_ :      str    				=				parent
										lowerCAmelCase_ :      str    				=				batch_size
										lowerCAmelCase_ :      Dict    				=				image_size
										lowerCAmelCase_ :      Dict    				=				num_channels
										lowerCAmelCase_ :      List[str]    				=				embeddings_size
										lowerCAmelCase_ :      List[Any]    				=				hidden_sizes
										lowerCAmelCase_ :      List[str]    				=				depths
										lowerCAmelCase_ :      List[Any]    				=				is_training
										lowerCAmelCase_ :      Dict    				=				use_labels
										lowerCAmelCase_ :      Any    				=				hidden_act
										lowerCAmelCase_ :      Union[str, Any]    				=				num_labels
										lowerCAmelCase_ :      Dict    				=				scope
										lowerCAmelCase_ :      Any    				=				len(__lowercase							)




						def 						lowercase_ (				self							)					->    Dict:
										lowerCAmelCase_ :      Any    				=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

										lowerCAmelCase_ :      str    				=				None
										if self.use_labels:
														lowerCAmelCase_ :      Dict    				=				ids_tensor([self.batch_size]   ,						self.num_labels							)

										lowerCAmelCase_ :      str    				=				self.get_config()
										return config, pixel_values, labels




						def 						lowercase_ (				self							)					->    Optional[int]:
										return RegNetConfig(
										    num_channels=self.num_channels   ,						embeddings_size=self.embeddings_size   ,						hidden_sizes=self.hidden_sizes   ,						depths=self.depths   ,						hidden_act=self.hidden_act   ,						num_labels=self.num_labels   ,						)




						def 						lowercase_ (				self   ,						__lowercase   ,						__lowercase   ,						__lowercase							)					->    Any:
										lowerCAmelCase_ :      List[str]    				=				TFRegNetModel(config=__lowercase							)
										lowerCAmelCase_ :      int    				=				model(__lowercase   ,						training=__lowercase							)
										# expected last hidden states: B, C, H // 32, W // 32
										self.parent.assertEqual(
										    result.last_hidden_state.shape   ,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2)   ,						)




						def 						lowercase_ (				self   ,						__lowercase   ,						__lowercase   ,						__lowercase							)					->    Any:
										lowerCAmelCase_ :      Any    				=				self.num_labels
										lowerCAmelCase_ :      List[str]    				=				TFRegNetForImageClassification(__lowercase							)
										lowerCAmelCase_ :      Any    				=				model(__lowercase   ,						labels=__lowercase   ,						training=__lowercase							)
										self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_labels)							)




						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_ :      Tuple    				=				self.prepare_config_and_inputs()
										lowerCAmelCase_				,  lowerCAmelCase_				,  lowerCAmelCase_ :      Optional[int]    				=				config_and_inputs
										lowerCAmelCase_ :      Any    				=				{'''pixel_values''': pixel_values}
										return config, inputs_dict







@require_tf
class 				snake_case__(							UpperCAmelCase__,						UpperCAmelCase__,						unittest.TestCase							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__      :  Tuple					=							(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
						SCREAMING_SNAKE_CASE__      :  int					=							(
						    {"""feature-extraction""": TFRegNetModel, """image-classification""": TFRegNetForImageClassification}
						    if is_tf_available()
						    else {}
						)

						SCREAMING_SNAKE_CASE__      :  Dict					=							False
						SCREAMING_SNAKE_CASE__      :  Tuple					=							False
						SCREAMING_SNAKE_CASE__      :  List[str]					=							False
						SCREAMING_SNAKE_CASE__      :  Tuple					=							False
						SCREAMING_SNAKE_CASE__      :  Dict					=							False




						def 						lowercase_ (				self							)					->    Optional[int]:
										lowerCAmelCase_ :      Any    				=				TFRegNetModelTester(self							)
										lowerCAmelCase_ :      Optional[int]    				=				ConfigTester(self   ,						config_class=__lowercase   ,						has_text_modality=__lowercase							)




						def 						lowercase_ (				self							)					->    Tuple:
										return




						@unittest.skip(reason='''RegNet does not use inputs_embeds'''							)
						def 						lowercase_ (				self							)					->    str:
										pass




						@unittest.skipIf(
						    not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''							)							) == 0   ,						reason='''TF does not support backprop for grouped convolutions on CPU.'''   ,						)
						@slow
						def 						lowercase_ (				self							)					->    Union[str, Any]:
										super().test_keras_fit()




						@unittest.skip(reason='''RegNet does not support input and output embeddings'''							)
						def 						lowercase_ (				self							)					->    int:
										pass




						def 						lowercase_ (				self							)					->    int:
										lowerCAmelCase_				,  lowerCAmelCase_ :      Tuple    				=				self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowerCAmelCase_ :      List[str]    				=				model_class(__lowercase							)
														lowerCAmelCase_ :      int    				=				inspect.signature(model.call							)
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														lowerCAmelCase_ :      Optional[Any]    				=				[*signature.parameters.keys()]

														lowerCAmelCase_ :      List[str]    				=				['''pixel_values''']
														self.assertListEqual(arg_names[:1]   ,						__lowercase							)




						def 						lowercase_ (				self							)					->    Union[str, Any]:
										lowerCAmelCase_ :      Dict    				=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__lowercase							)




						def 						lowercase_ (				self							)					->    List[Any]:
										def check_hidden_states_output(__lowercase   ,						__lowercase   ,						__lowercase							):
														lowerCAmelCase_ :      List[Any]    				=				model_class(__lowercase							)
														lowerCAmelCase_ :      Any    				=				model(**self._prepare_for_class(__lowercase   ,						__lowercase							)   ,						training=__lowercase							)

														lowerCAmelCase_ :      Union[str, Any]    				=				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

														lowerCAmelCase_ :      Union[str, Any]    				=				self.model_tester.num_stages
														self.assertEqual(len(__lowercase							)   ,						expected_num_stages + 1							)

														# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
														self.assertListEqual(
														    list(hidden_states[0].shape[-2:]							)   ,						[self.model_tester.image_size // 2, self.model_tester.image_size // 2]   ,						)

										lowerCAmelCase_				,  lowerCAmelCase_ :      List[Any]    				=				self.model_tester.prepare_config_and_inputs_for_common()
										lowerCAmelCase_ :      Optional[Any]    				=				['''basic''', '''bottleneck''']
										for model_class in self.all_model_classes:
														for layer_type in layers_type:
																		lowerCAmelCase_ :      Union[str, Any]    				=				layer_type
																		lowerCAmelCase_ :      Tuple    				=				True
																		check_hidden_states_output(__lowercase   ,						__lowercase   ,						__lowercase							)

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		lowerCAmelCase_ :      Optional[Any]    				=				True

																		check_hidden_states_output(__lowercase   ,						__lowercase   ,						__lowercase							)




						def 						lowercase_ (				self							)					->    Optional[int]:
										lowerCAmelCase_				,  lowerCAmelCase_ :      Tuple    				=				self.model_tester.prepare_config_and_inputs_for_common()

										def check_equivalence(__lowercase   ,						__lowercase   ,						__lowercase   ,						__lowercase={}							):
														lowerCAmelCase_ :      List[str]    				=				model(__lowercase   ,						return_dict=__lowercase   ,						**__lowercase							)
														lowerCAmelCase_ :      List[Any]    				=				model(__lowercase   ,						return_dict=__lowercase   ,						**__lowercase							).to_tuple()

														def recursive_check(__lowercase   ,						__lowercase							):
																		if isinstance(__lowercase   ,						(List, Tuple)							):
																						for tuple_iterable_value, dict_iterable_value in zip(__lowercase   ,						__lowercase							):
																										recursive_check(__lowercase   ,						__lowercase							)
																		elif tuple_object is None:
																						return
																		else:
																						self.assertTrue(
																						    all(tf.equal(__lowercase   ,						__lowercase							)							)   ,						msg=(
																						        '''Tuple and dict output are not equal. Difference:'''
																						        f""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object							)							)}"""
																						    )   ,						)

																		recursive_check(__lowercase   ,						__lowercase							)

										for model_class in self.all_model_classes:
														lowerCAmelCase_ :      Any    				=				model_class(__lowercase							)

														lowerCAmelCase_ :      int    				=				self._prepare_for_class(__lowercase   ,						__lowercase							)
														lowerCAmelCase_ :      Union[str, Any]    				=				self._prepare_for_class(__lowercase   ,						__lowercase							)
														check_equivalence(__lowercase   ,						__lowercase   ,						__lowercase							)

														lowerCAmelCase_ :      Optional[int]    				=				self._prepare_for_class(__lowercase   ,						__lowercase   ,						return_labels=__lowercase							)
														lowerCAmelCase_ :      str    				=				self._prepare_for_class(__lowercase   ,						__lowercase   ,						return_labels=__lowercase							)
														check_equivalence(__lowercase   ,						__lowercase   ,						__lowercase							)

														lowerCAmelCase_ :      List[Any]    				=				self._prepare_for_class(__lowercase   ,						__lowercase							)
														lowerCAmelCase_ :      Optional[int]    				=				self._prepare_for_class(__lowercase   ,						__lowercase							)
														check_equivalence(__lowercase   ,						__lowercase   ,						__lowercase   ,						{'''output_hidden_states''': True}							)

														lowerCAmelCase_ :      int    				=				self._prepare_for_class(__lowercase   ,						__lowercase   ,						return_labels=__lowercase							)
														lowerCAmelCase_ :      Any    				=				self._prepare_for_class(__lowercase   ,						__lowercase   ,						return_labels=__lowercase							)
														check_equivalence(__lowercase   ,						__lowercase   ,						__lowercase   ,						{'''output_hidden_states''': True}							)




						def 						lowercase_ (				self							)					->    List[Any]:
										lowerCAmelCase_ :      Tuple    				=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*__lowercase							)




						@slow
						def 						lowercase_ (				self							)					->    int:
										for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCAmelCase_ :      List[Any]    				=				TFRegNetModel.from_pretrained(__lowercase							)
														self.assertIsNotNone(__lowercase							)






def 			lowerCAmelCase (		)-> Optional[Any]:
				lowerCAmelCase_ :      int    				=				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
				return image







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







						'''simple docstring'''




						@cached_property
						def 						lowercase_ (				self							)					->    Optional[Any]:
										return (
										    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
										    if is_vision_available()
										    else None
										)




						@slow
						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_ :      Optional[int]    				=				TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)

										lowerCAmelCase_ :      Optional[int]    				=				self.default_image_processor
										lowerCAmelCase_ :      Dict    				=				prepare_img()
										lowerCAmelCase_ :      Optional[int]    				=				image_processor(images=__lowercase   ,						return_tensors='''tf'''							)

										# forward pass
										lowerCAmelCase_ :      Optional[int]    				=				model(**__lowercase   ,						training=__lowercase							)

										# verify the logits
										lowerCAmelCase_ :      Dict    				=				tf.TensorShape((1, 1_0_0_0)							)
										self.assertEqual(outputs.logits.shape   ,						__lowercase							)

										lowerCAmelCase_ :      Union[str, Any]    				=				tf.constant([-0.41_80, -1.50_51, -3.48_36]							)

										tf.debugging.assert_near(outputs.logits[0, :3]   ,						__lowercase   ,						atol=1e-4							)



import csv

import tweepy

# Twitter API credentials
_UpperCAmelCase			:  int     =""""""
_UpperCAmelCase			:  Optional[int]     =""""""
_UpperCAmelCase			:  Dict     =""""""
_UpperCAmelCase			:  str     =""""""



def 			lowerCAmelCase (		lowerCAmelCase_ )-> None:
				# authorize twitter, initialize tweepy
				lowerCAmelCase_ :      Optional[int]    				=				tweepy.OAuthHandler(lowerCAmelCase_ ,   lowerCAmelCase_ )
				auth.set_access_token(lowerCAmelCase_ ,   lowerCAmelCase_ )
				lowerCAmelCase_ :      Any    				=				tweepy.API(lowerCAmelCase_ )

				# initialize a list to hold all the tweepy Tweets
				lowerCAmelCase_ :      Dict    				=				[]

				# make initial request for most recent tweets (200 is the maximum allowed count)
				lowerCAmelCase_ :      Optional[int]    				=				api.user_timeline(screen_name=lowerCAmelCase_ ,   count=200 )

				# save most recent tweets
				alltweets.extend(lowerCAmelCase_ )

				# save the id of the oldest tweet less one
				lowerCAmelCase_ :      str    				=				alltweets[-1].id - 1

				# keep grabbing tweets until there are no tweets left to grab
				while len(lowerCAmelCase_ ) > 0:
								print(f"""getting tweets before {oldest}""" )

								# all subsequent requests use the max_id param to prevent duplicates
								lowerCAmelCase_ :      Optional[Any]    				=				api.user_timeline(
								    screen_name=lowerCAmelCase_ ,   count=200 ,   max_id=lowerCAmelCase_ )

								# save most recent tweets
								alltweets.extend(lowerCAmelCase_ )

								# update the id of the oldest tweet less one
								lowerCAmelCase_ :      Optional[Any]    				=				alltweets[-1].id - 1

								print(f"""...{len(lowerCAmelCase_ )} tweets downloaded so far""" )

				# transform the tweepy tweets into a 2D array that will populate the csv
				lowerCAmelCase_ :      Union[str, Any]    				=				[[tweet.id_str, tweet.created_at, tweet.text] for tweet in alltweets]

				# write the csv
				with open(f"""new_{screen_name}_tweets.csv""" ,   '''w''' ) as f:
								lowerCAmelCase_ :      Optional[int]    				=				csv.writer(lowerCAmelCase_ )
								writer.writerow(['''id''', '''created_at''', '''text'''] )
								writer.writerows(lowerCAmelCase_ )


if __name__ == "__main__":
						# pass in the username of the account you want to download
						get_all_tweets("""FirePing32""")