





from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

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 TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
		from PIL import Image

		from transformers import ViTImageProcessor


class 						lowerCamelCase       :







							"""simple docstring"""




							def __init__( self     :					Optional[Any],			_UpperCAmelCase     :					List[str],			_UpperCAmelCase     :					Any=1_3,			_UpperCAmelCase     :					Dict=3_0,			_UpperCAmelCase     :					Dict=2,			_UpperCAmelCase     :					Dict=3,			_UpperCAmelCase     :					Optional[Any]=True,			_UpperCAmelCase     :					Any=True,			_UpperCAmelCase     :					Dict=3_2,			_UpperCAmelCase     :					str=2,			_UpperCAmelCase     :					List[Any]=4,			_UpperCAmelCase     :					Tuple=3_7,			_UpperCAmelCase     :					Dict="gelu",			_UpperCAmelCase     :					Optional[Any]=0.1,			_UpperCAmelCase     :					List[Any]=0.1,			_UpperCAmelCase     :					Tuple=1_0,			_UpperCAmelCase     :					Dict=0.02,			_UpperCAmelCase     :					Union[str, Any]=3,			_UpperCAmelCase     :					List[str]=0.6,			_UpperCAmelCase     :					Tuple=None,			)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Tuple     =						parent
														SCREAMING_SNAKE_CASE__       :      Any     =						batch_size
														SCREAMING_SNAKE_CASE__       :      int     =						image_size
														SCREAMING_SNAKE_CASE__       :      str     =						patch_size
														SCREAMING_SNAKE_CASE__       :      Dict     =						num_channels
														SCREAMING_SNAKE_CASE__       :      List[str]     =						is_training
														SCREAMING_SNAKE_CASE__       :      str     =						use_labels
														SCREAMING_SNAKE_CASE__       :      Tuple     =						hidden_size
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						num_hidden_layers
														SCREAMING_SNAKE_CASE__       :      List[str]     =						num_attention_heads
														SCREAMING_SNAKE_CASE__       :      int     =						intermediate_size
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						hidden_act
														SCREAMING_SNAKE_CASE__       :      Dict     =						hidden_dropout_prob
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						attention_probs_dropout_prob
														SCREAMING_SNAKE_CASE__       :      Any     =						type_sequence_label_size
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						initializer_range
														SCREAMING_SNAKE_CASE__       :      Any     =						mask_ratio
														SCREAMING_SNAKE_CASE__       :      int     =						scope

														# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
														# (we add 1 for the [CLS] token)
														SCREAMING_SNAKE_CASE__       :      Dict     =						(image_size // patch_size) ** 2
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						int(math.ceil((1 - mask_ratio) * (num_patches + 1)						)						)






							def  A_     ( self     :					Tuple						)				->			List[str]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						None
														if self.use_labels:
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						ids_tensor([self.batch_size],			self.type_sequence_label_size						)

														SCREAMING_SNAKE_CASE__       :      Dict     =						self.get_config()

														return config, pixel_values, labels






							def  A_     ( self     :					int						)				->			str:





														"""simple docstring"""
														return ViTMAEConfig(
														    image_size=self.image_size,			patch_size=self.patch_size,			num_channels=self.num_channels,			hidden_size=self.hidden_size,			num_hidden_layers=self.num_hidden_layers,			num_attention_heads=self.num_attention_heads,			intermediate_size=self.intermediate_size,			decoder_hidden_size=self.hidden_size,			decoder_num_hidden_layers=self.num_hidden_layers,			decoder_num_attention_heads=self.num_attention_heads,			decoder_intermediate_size=self.intermediate_size,			hidden_act=self.hidden_act,			hidden_dropout_prob=self.hidden_dropout_prob,			attention_probs_dropout_prob=self.attention_probs_dropout_prob,			is_decoder=__snake_case,			initializer_range=self.initializer_range,			mask_ratio=self.mask_ratio,			)






							def  A_     ( self     :					Tuple,			_UpperCAmelCase     :					List[str],			_UpperCAmelCase     :					List[str],			_UpperCAmelCase     :					Dict						)				->			List[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						TFViTMAEModel(config=__snake_case						)
														SCREAMING_SNAKE_CASE__       :      str     =						model(__snake_case,			training=__snake_case						)
														self.parent.assertEqual(result.last_hidden_state.shape,			(self.batch_size, self.seq_length, self.hidden_size)						)






							def  A_     ( self     :					Tuple,			_UpperCAmelCase     :					Dict,			_UpperCAmelCase     :					Any,			_UpperCAmelCase     :					str						)				->			Any:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Dict     =						TFViTMAEForPreTraining(__snake_case						)
														SCREAMING_SNAKE_CASE__       :      int     =						model(__snake_case,			training=__snake_case						)
														# expected sequence length = num_patches
														SCREAMING_SNAKE_CASE__       :      Dict     =						(self.image_size // self.patch_size) ** 2
														SCREAMING_SNAKE_CASE__       :      List[str]     =						self.patch_size**2 * self.num_channels
														self.parent.assertEqual(result.logits.shape,			(self.batch_size, num_patches, expected_num_channels)						)

														# test greyscale images
														SCREAMING_SNAKE_CASE__       :      int     =						1
														SCREAMING_SNAKE_CASE__       :      List[str]     =						TFViTMAEForPreTraining(__snake_case						)

														SCREAMING_SNAKE_CASE__       :      Tuple     =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						model(__snake_case,			training=__snake_case						)
														SCREAMING_SNAKE_CASE__       :      Any     =						self.patch_size**2
														self.parent.assertEqual(result.logits.shape,			(self.batch_size, num_patches, expected_num_channels)						)






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.prepare_config_and_inputs()
														((SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__))       :      Dict     =						config_and_inputs
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						{"pixel_values": pixel_values}
														return config, inputs_dict


@require_tf
class 						lowerCamelCase       (lowerCamelCase_							,     lowerCamelCase_							,     unittest.TestCase      ):







							"""simple docstring"""




							UpperCAmelCase_      						=   (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
							UpperCAmelCase_      						=   {'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

							UpperCAmelCase_      						=   False
							UpperCAmelCase_      						=   False
							UpperCAmelCase_      						=   False
							UpperCAmelCase_      						=   False






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						TFViTMAEModelTester(self						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						ConfigTester(self,			config_class=__snake_case,			has_text_modality=__snake_case,			hidden_size=3_7						)






							def  A_     ( self     :					str						)				->			Any:





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






							@unittest.skip(reason="ViTMAE does not use inputs_embeds"						)
							def  A_     ( self     :					str						)				->			int:





														"""simple docstring"""
														pass






							def  A_     ( self     :					Tuple						)				->			Union[str, Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						model_class(__snake_case						)
																					self.assertIsInstance(model.get_input_embeddings(),			(tf.keras.layers.Layer)						)
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						model.get_output_embeddings()
																					self.assertTrue(x is None or isinstance(__snake_case,			tf.keras.layers.Layer						)						)






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.model_tester.prepare_config_and_inputs_for_common()

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

																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						["pixel_values"]
																					self.assertListEqual(arg_names[:1],			__snake_case						)






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Any     =						self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*__snake_case						)






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      int     =						self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_pretraining(*__snake_case						)






							def  A_     ( self     :					List[Any]						)				->			Any:





														"""simple docstring"""
														# make the mask reproducible
														np.random.seed(2						)

														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.model_tester.prepare_config_and_inputs_for_common()

														SCREAMING_SNAKE_CASE__       :      List[str]     =						int((config.image_size // config.patch_size) ** 2						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						np.random.uniform(size=(self.model_tester.batch_size, num_patches)						)

														for model_class in self.all_model_classes:
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						model_class(__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      List[str]     =						self._prepare_for_class(__snake_case,			__snake_case						)

																					SCREAMING_SNAKE_CASE__       :      str     =						model(__snake_case,			noise=__snake_case						)

																					SCREAMING_SNAKE_CASE__       :      Dict     =						copy.deepcopy(self._prepare_for_class(__snake_case,			__snake_case						)						)
																					SCREAMING_SNAKE_CASE__       :      int     =						model(**__snake_case,			noise=__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						outputs_dict[0].numpy()
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						outputs_keywords[0].numpy()

																					self.assertLess(np.sum(np.abs(output_dict - output_keywords						)						),			1E-6						)






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





														"""simple docstring"""
														# make the mask reproducible
														np.random.seed(2						)

														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      int     =						self.model_tester.prepare_config_and_inputs_for_common()

														SCREAMING_SNAKE_CASE__       :      int     =						int((config.image_size // config.patch_size) ** 2						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						np.random.uniform(size=(self.model_tester.batch_size, num_patches)						)

														def prepare_numpy_arrays(_UpperCAmelCase     :					Tuple						):
																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						{}
																					for k, v in inputs_dict.items():
																												if tf.is_tensor(__snake_case						):
																																			SCREAMING_SNAKE_CASE__       :      List[Any]     =						v.numpy()
																												else:
																																			SCREAMING_SNAKE_CASE__       :      str     =						np.array(__snake_case						)

																					return inputs_np_dict

														for model_class in self.all_model_classes:
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						model_class(__snake_case						)

																					SCREAMING_SNAKE_CASE__       :      Tuple     =						self._prepare_for_class(__snake_case,			__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						prepare_numpy_arrays(__snake_case						)

																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						model(__snake_case,			noise=__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      int     =						model(**__snake_case,			noise=__snake_case						)
																					self.assert_outputs_same(__snake_case,			__snake_case						)






							def  A_     ( self     :					Any,			_UpperCAmelCase     :					Optional[Any],			_UpperCAmelCase     :					Optional[Any],			_UpperCAmelCase     :					List[str]						)				->			List[str]:





														"""simple docstring"""
														# make masks reproducible
														np.random.seed(2						)

														SCREAMING_SNAKE_CASE__       :      List[str]     =						int((tf_model.config.image_size // tf_model.config.patch_size) ** 2						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						np.random.uniform(size=(self.model_tester.batch_size, num_patches)						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						tf.constant(__snake_case						)

														# Add `noise` argument.
														# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						tf_noise

														super().check_pt_tf_models(__snake_case,			__snake_case,			__snake_case						)






							def  A_     ( self     :					Any						)				->			Optional[int]:





														"""simple docstring"""
														# make mask reproducible
														np.random.seed(2						)

														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      int     =						self.model_tester.prepare_config_and_inputs_for_common()

														SCREAMING_SNAKE_CASE__       :      List[str]     =						{
														    module_member
														    for model_class in self.all_model_classes
														    for module in (import_module(model_class.__module__						),)
														    for module_member_name in dir(__snake_case						)
														    if module_member_name.endswith("MainLayer"						)
														    # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
														    and module_member_name[: -len("MainLayer"						)] == model_class.__name__[: -len("Model"						)]
														    for module_member in (getattr(__snake_case,			__snake_case						),)
														    if isinstance(__snake_case,			__snake_case						)
														    and tf.keras.layers.Layer in module_member.__bases__
														    and getattr(__snake_case,			"_keras_serializable",			__snake_case						)
														}

														SCREAMING_SNAKE_CASE__       :      List[Any]     =						int((config.image_size // config.patch_size) ** 2						)
														SCREAMING_SNAKE_CASE__       :      Any     =						np.random.uniform(size=(self.model_tester.batch_size, num_patches)						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						tf.convert_to_tensor(__snake_case						)
														inputs_dict.update({"noise": noise}						)

														for main_layer_class in tf_main_layer_classes:
																					SCREAMING_SNAKE_CASE__       :      str     =						main_layer_class(__snake_case						)

																					SCREAMING_SNAKE_CASE__       :      Dict     =						{
																					    name: tf.keras.Input(tensor.shape[1:],			dtype=tensor.dtype						) for name, tensor in inputs_dict.items()
																					}

																					SCREAMING_SNAKE_CASE__       :      int     =						tf.keras.Model(__snake_case,			outputs=main_layer(__snake_case						)						)
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						model(__snake_case						)

																					with tempfile.TemporaryDirectory() as tmpdirname:
																												SCREAMING_SNAKE_CASE__       :      str     =						os.path.join(__snake_case,			"keras_model.h5"						)
																												model.save(__snake_case						)
																												SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						tf.keras.models.load_model(
																												    __snake_case,			custom_objects={main_layer_class.__name__: main_layer_class}						)
																												assert isinstance(__snake_case,			tf.keras.Model						)
																												SCREAMING_SNAKE_CASE__       :      List[Any]     =						model(__snake_case						)
																												self.assert_outputs_same(__snake_case,			__snake_case						)






							@slow
							def  A_     ( self     :					str						)				->			int:





														"""simple docstring"""
														# make mask reproducible
														np.random.seed(2						)

														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      List[Any]     =						self.model_tester.prepare_config_and_inputs_for_common()

														SCREAMING_SNAKE_CASE__       :      List[str]     =						int((config.image_size // config.patch_size) ** 2						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						np.random.uniform(size=(self.model_tester.batch_size, num_patches)						)

														for model_class in self.all_model_classes:
																					SCREAMING_SNAKE_CASE__       :      int     =						model_class(__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      List[str]     =						self._prepare_for_class(__snake_case,			__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						model(__snake_case,			noise=__snake_case						)

																					if model_class.__name__ == "TFViTMAEModel":
																												SCREAMING_SNAKE_CASE__       :      int     =						outputs.last_hidden_state.numpy()
																												SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						0
																					else:
																												SCREAMING_SNAKE_CASE__       :      Any     =						outputs.logits.numpy()
																												SCREAMING_SNAKE_CASE__       :      Dict     =						0

																					with tempfile.TemporaryDirectory() as tmpdirname:
																												model.save_pretrained(__snake_case,			saved_model=__snake_case						)
																												SCREAMING_SNAKE_CASE__       :      Any     =						model_class.from_pretrained(__snake_case						)
																												SCREAMING_SNAKE_CASE__       :      int     =						model(__snake_case,			noise=__snake_case						)

																												if model_class.__name__ == "TFViTMAEModel":
																																			SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						after_outputs["last_hidden_state"].numpy()
																																			SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						0
																												else:
																																			SCREAMING_SNAKE_CASE__       :      Any     =						after_outputs["logits"].numpy()
																																			SCREAMING_SNAKE_CASE__       :      List[str]     =						0

																												SCREAMING_SNAKE_CASE__       :      List[Any]     =						np.amax(np.abs(out_a - out_a						)						)
																												self.assertLessEqual(__snake_case,			1E-5						)






							def  A_     ( self     :					List[str]						)				->			List[Any]:





														"""simple docstring"""
														# make mask reproducible
														np.random.seed(2						)

														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.model_tester.prepare_config_and_inputs_for_common()

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						int((config.image_size // config.patch_size) ** 2						)
														SCREAMING_SNAKE_CASE__       :      str     =						np.random.uniform(size=(self.model_tester.batch_size, num_patches)						)

														for model_class in self.all_model_classes:
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						model_class(__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						self._prepare_for_class(__snake_case,			__snake_case						)

																					SCREAMING_SNAKE_CASE__       :      str     =						model(__snake_case,			noise=__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      int     =						model.get_config()
																					# make sure that returned config is jsonifiable, which is required by keras
																					json.dumps(__snake_case						)
																					SCREAMING_SNAKE_CASE__       :      Dict     =						model_class.from_config(model.get_config()						)
																					# make sure it also accepts a normal config
																					SCREAMING_SNAKE_CASE__       :      Tuple     =						model_class.from_config(model.config						)
																					SCREAMING_SNAKE_CASE__       :      int     =						new_model(__snake_case						)  # Build model
																					new_model.set_weights(model.get_weights()						)
																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						new_model(__snake_case,			noise=__snake_case						)

																					self.assert_outputs_same(__snake_case,			__snake_case						)






							@unittest.skip(
							    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."						)
							def  A_     ( self     :					Optional[int]						)				->			Union[str, Any]:





														"""simple docstring"""
														pass






							@unittest.skip(reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"						)
							def  A_     ( self     :					Optional[Any]						)				->			Dict:





														"""simple docstring"""
														pass






							@slow
							def  A_     ( self     :					Tuple						)				->			List[str]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						TFViTMAEModel.from_pretrained("google/vit-base-patch16-224"						)
														self.assertIsNotNone(__snake_case						)


def _a (  )	->    Optional[int]:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      Any     =						Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
							return image







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







							"""simple docstring"""




							@cached_property
							def  A_     ( self     :					Optional[Any]						)				->			List[str]:





														"""simple docstring"""
														return ViTImageProcessor.from_pretrained("facebook/vit-mae-base"						) if is_vision_available() else None






							@slow
							def  A_     ( self     :					List[str]						)				->			str:





														"""simple docstring"""
														# make random mask reproducible across the PT and TF model
														np.random.seed(2						)

														SCREAMING_SNAKE_CASE__       :      Dict     =						TFViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base"						)

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.default_image_processor
														SCREAMING_SNAKE_CASE__       :      Any     =						prepare_img()
														SCREAMING_SNAKE_CASE__       :      int     =						image_processor(images=__snake_case,			return_tensors="tf"						)

														# prepare a noise vector that will be also used for testing the TF model
														# (this way we can ensure that the PT and TF models operate on the same inputs)
														SCREAMING_SNAKE_CASE__       :      str     =						ViTMAEConfig()
														SCREAMING_SNAKE_CASE__       :      str     =						int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2						)
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						np.random.uniform(size=(1, num_patches)						)

														# forward pass
														SCREAMING_SNAKE_CASE__       :      Dict     =						model(**__snake_case,			noise=__snake_case						)

														# verify the logits
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						tf.convert_to_tensor([1, 1_9_6, 7_6_8]						)
														self.assertEqual(outputs.logits.shape,			__snake_case						)

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						tf.convert_to_tensor(
														    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]]						)

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













import webbrowser
from sys import argv
from urllib.parse import parse_qs, quote

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
		_lowerCamelCase :    Union[str, Any]  							= '''%20'''.join(argv[1:]) if len(argv) > 1 else quote(str(input('''Search: ''')))

		print('''Googling.....''')

		_lowerCamelCase :    Any  							= f"https://www.google.com/search?q={query}&num=100"

		_lowerCamelCase :    Optional[Any]  							= requests.get(
		    url,
		    headers={'''User-Agent''': str(UserAgent().random)},
		)

		try:
				_lowerCamelCase :    Union[str, Any]  							= (
				    BeautifulSoup(res.text, '''html.parser''')
				    .find('''div''', attrs={'''class''': '''yuRUbf'''})
				    .find('''a''')
				    .get('''href''')
				)

		except AttributeError:
				_lowerCamelCase :    Optional[Any]  							= parse_qs(
				    BeautifulSoup(res.text, '''html.parser''')
				    .find('''div''', attrs={'''class''': '''kCrYT'''})
				    .find('''a''')
				    .get('''href''')
				)['''url'''][0]

		webbrowser.open(link)






