




'''simple docstring'''





import inspect
import unittest

import numpy as np

from transformers import ViTConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
   import jax

   from transformers.models.vit.modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel

class        _a    (						unittest.TestCase							):






     def __init__(			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE=13 ,_SCREAMING_SNAKE_CASE=30 ,_SCREAMING_SNAKE_CASE=2 ,_SCREAMING_SNAKE_CASE=3 ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=32 ,_SCREAMING_SNAKE_CASE=5 ,_SCREAMING_SNAKE_CASE=4 ,_SCREAMING_SNAKE_CASE=37 ,_SCREAMING_SNAKE_CASE="gelu" ,_SCREAMING_SNAKE_CASE=0.1 ,_SCREAMING_SNAKE_CASE=0.1 ,_SCREAMING_SNAKE_CASE=10 ,_SCREAMING_SNAKE_CASE=0.0_2 ,)							->      Optional[Any]:
          _snake_case							=				parent
          _snake_case							=				batch_size
          _snake_case							=				image_size
          _snake_case							=				patch_size
          _snake_case							=				num_channels
          _snake_case							=				is_training
          _snake_case							=				use_labels
          _snake_case							=				hidden_size
          _snake_case							=				num_hidden_layers
          _snake_case							=				num_attention_heads
          _snake_case							=				intermediate_size
          _snake_case							=				hidden_act
          _snake_case							=				hidden_dropout_prob
          _snake_case							=				attention_probs_dropout_prob
          _snake_case							=				type_sequence_label_size
          _snake_case							=				initializer_range

          # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
          _snake_case							=				(image_size // patch_size) ** 2
          _snake_case							=				num_patches + 1






     def     _lowercase     (			self   )							->      Optional[int]:
          _snake_case							=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

          _snake_case							=				ViTConfig(
              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 ,hidden_act=self.hidden_act ,hidden_dropout_prob=self.hidden_dropout_prob ,attention_probs_dropout_prob=self.attention_probs_dropout_prob ,is_decoder=_SCREAMING_SNAKE_CASE ,initializer_range=self.initializer_range ,)

          return config, pixel_values






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      List[Any]:
          _snake_case							=				FlaxViTModel(config=_SCREAMING_SNAKE_CASE   )
          _snake_case							=				model(_SCREAMING_SNAKE_CASE   )
          # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
          _snake_case							=				(self.image_size, self.image_size)
          _snake_case							=				(self.patch_size, self.patch_size)
          _snake_case							=				(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
          self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, num_patches + 1, self.hidden_size)   )






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Optional[int]:
          _snake_case							=				self.type_sequence_label_size
          _snake_case							=				FlaxViTForImageClassification(config=_SCREAMING_SNAKE_CASE   )
          _snake_case							=				model(_SCREAMING_SNAKE_CASE   )
          self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size)   )

          # test greyscale images
          _snake_case							=				1
          _snake_case							=				FlaxViTForImageClassification(_SCREAMING_SNAKE_CASE   )

          _snake_case							=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
          _snake_case							=				model(_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self   )							->      int:
          _snake_case							=				self.prepare_config_and_inputs()
          (
              (
              _snake_case
          )							, (
              _snake_case
          )							, 
          )							=				config_and_inputs
          _snake_case							=				{"pixel_values": pixel_values}
          return config, inputs_dict







@require_flax
class        _a    (						__lowerCAmelCase , unittest.TestCase							):
     SCREAMING_SNAKE_CASE_							:   List[Any]       =						(FlaxViTModel, FlaxViTForImageClassification) if is_flax_available() else ()






     def     _lowercase     (			self   )							->      None:
          _snake_case							=				FlaxViTModelTester(self   )
          _snake_case							=				ConfigTester(self ,config_class=_SCREAMING_SNAKE_CASE ,has_text_modality=_SCREAMING_SNAKE_CASE ,hidden_size=37   )






     def     _lowercase     (			self   )							->      Optional[Any]:
          self.config_tester.run_common_tests()






     def     _lowercase     (			self   )							->      Dict:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self   )							->      Any:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self   )							->      Optional[int]:
          _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(_SCREAMING_SNAKE_CASE   )
               _snake_case							=				inspect.signature(model.__call__   )
               # 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] ,_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self   )							->      Any:
          _snake_case							, _snake_case							=				self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__   ):
                    _snake_case							=				self._prepare_for_class(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )
                    _snake_case							=				model_class(_SCREAMING_SNAKE_CASE   )

                    @jax.jit
                    def model_jitted(_SCREAMING_SNAKE_CASE ,**_SCREAMING_SNAKE_CASE   ):
                         return model(pixel_values=_SCREAMING_SNAKE_CASE ,**_SCREAMING_SNAKE_CASE   )

                    with self.subTest("JIT Enabled"   ):
                         _snake_case							=				model_jitted(**_SCREAMING_SNAKE_CASE   ).to_tuple()

                    with self.subTest("JIT Disabled"   ):
                         with jax.disable_jit():
                              _snake_case							=				model_jitted(**_SCREAMING_SNAKE_CASE   ).to_tuple()

                    self.assertEqual(len(_SCREAMING_SNAKE_CASE   ) ,len(_SCREAMING_SNAKE_CASE   )   )
                    for jitted_output, output in zip(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   ):
                         self.assertEqual(jitted_output.shape ,output.shape   )






     @slow
     def     _lowercase     (			self   )							->      Union[str, Any]:
          for model_class_name in self.all_model_classes:
               _snake_case							=				model_class_name.from_pretrained("google/vit-base-patch16-224"   )
               _snake_case							=				model(np.ones((1, 3, 224, 224)   )   )
               self.assertIsNotNone(_SCREAMING_SNAKE_CASE   )








'''simple docstring'''





import pprint

import requests

UpperCamelCase_						:      Tuple       =						'''https://zenquotes.io/api'''





def      __a     (       )						->			list:

     """simple docstring"""




     return requests.get(API_ENDPOINT_URL + "/today"   ).json()





def      __a     (       )						->			list:

     """simple docstring"""




     return requests.get(API_ENDPOINT_URL + "/random"   ).json()


if __name__ == "__main__":
   UpperCamelCase_						:      Any       =						random_quotes()
   pprint.pprint(response)


