






"""simple docstring"""



import tempfile
import unittest

import transformers
from transformers import XGLMConfig, XGLMTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, require_sentencepiece, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
 import jax
 import jax.numpy as jnp
 import numpy as np

 from transformers.modeling_flax_pytorch_utils import (
     convert_pytorch_state_dict_to_flax,
     load_flax_weights_in_pytorch_model,
 )
 from transformers.models.xglm.modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel


if is_torch_available():
 import torch


@require_flax
class 	_UpperCamelCase :



    '''simple docstring'''


    def __init__(      self   ,			__lowercase   ,			__lowercase=14   ,			__lowercase=7   ,			__lowercase=True   ,			__lowercase=True   ,			__lowercase=True   ,			__lowercase=99   ,			__lowercase=32   ,			__lowercase=5   ,			__lowercase=4   ,			__lowercase=37   ,			__lowercase="gelu"   ,			__lowercase=0.1   ,			__lowercase=0.1   ,			__lowercase=512   ,			__lowercase=0.02   ,			__lowercase=None   ,			):
     UpperCAmelCase__ 						=				parent
     UpperCAmelCase__ 						=				batch_size
     UpperCAmelCase__ 						=				seq_length
     UpperCAmelCase__ 						=				is_training
     UpperCAmelCase__ 						=				use_input_mask
     UpperCAmelCase__ 						=				use_labels
     UpperCAmelCase__ 						=				vocab_size
     UpperCAmelCase__ 						=				d_model
     UpperCAmelCase__ 						=				num_hidden_layers
     UpperCAmelCase__ 						=				num_attention_heads
     UpperCAmelCase__ 						=				ffn_dim
     UpperCAmelCase__ 						=				activation_function
     UpperCAmelCase__ 						=				activation_dropout
     UpperCAmelCase__ 						=				attention_dropout
     UpperCAmelCase__ 						=				max_position_embeddings
     UpperCAmelCase__ 						=				initializer_range
     UpperCAmelCase__ 						=				None
     UpperCAmelCase__ 						=				0
     UpperCAmelCase__ 						=				2
     UpperCAmelCase__ 						=				1


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				np.clip(ids_tensor([self.batch_size, self.seq_length]   ,			self.vocab_size			)   ,			3   ,			self.vocab_size			)

     UpperCAmelCase__ 						=				None
     if self.use_input_mask:
      UpperCAmelCase__ 						=				random_attention_mask([self.batch_size, self.seq_length]			)

     UpperCAmelCase__ 						=				XGLMConfig(
         vocab_size=self.vocab_size   ,			d_model=self.hidden_size   ,			num_layers=self.num_hidden_layers   ,			attention_heads=self.num_attention_heads   ,			ffn_dim=self.ffn_dim   ,			activation_function=self.activation_function   ,			activation_dropout=self.activation_dropout   ,			attention_dropout=self.attention_dropout   ,			max_position_embeddings=self.max_position_embeddings   ,			initializer_range=self.initializer_range   ,			use_cache=SCREAMING_SNAKE_CASE_   ,			bos_token_id=self.bos_token_id   ,			eos_token_id=self.eos_token_id   ,			pad_token_id=self.pad_token_id   ,			)

     return (config, input_ids, input_mask)


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				self.prepare_config_and_inputs()
     UpperCAmelCase__ 						=				config_and_inputs
     UpperCAmelCase__ 						=				{'input_ids': input_ids, 'attention_mask': attention_mask}
     return config, inputs_dict


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				self.prepare_config_and_inputs()

     UpperCAmelCase__ 						=				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
     UpperCAmelCase__ 						=				ids_tensor([self.batch_size, self.seq_length]   ,			vocab_size=2			)

     return (
         config,
         input_ids,
         attention_mask,
         encoder_hidden_states,
         encoder_attention_mask,
     )


    def 		A__      (      self   ,			__lowercase   ,			__lowercase   ,			__lowercase   ,			__lowercase			):
     UpperCAmelCase__ 						=				20
     UpperCAmelCase__ 						=				model_class_name(SCREAMING_SNAKE_CASE_			)

     UpperCAmelCase__ 						=				model.init_cache(input_ids.shape[0]   ,			SCREAMING_SNAKE_CASE_			)
     UpperCAmelCase__ 						=				jnp.ones((input_ids.shape[0], max_decoder_length)   ,			dtype="""i4"""			)

     UpperCAmelCase__ 						=				jnp.broadcast_to(
         jnp.arange(input_ids.shape[-1] - 1			)[None, :]   ,			(input_ids.shape[0], input_ids.shape[-1] - 1)			)
     UpperCAmelCase__ 						=				model(
         input_ids[:, :-1]   ,			attention_mask=SCREAMING_SNAKE_CASE_   ,			past_key_values=SCREAMING_SNAKE_CASE_   ,			position_ids=SCREAMING_SNAKE_CASE_   ,			)

     UpperCAmelCase__ 						=				jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]   ,			dtype="""i4"""			)
     UpperCAmelCase__ 						=				model(
         input_ids[:, -1:]   ,			attention_mask=SCREAMING_SNAKE_CASE_   ,			past_key_values=outputs_cache.past_key_values   ,			position_ids=SCREAMING_SNAKE_CASE_   ,			)

     UpperCAmelCase__ 						=				model(SCREAMING_SNAKE_CASE_			)

     UpperCAmelCase__ 						=				np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
     self.parent.assertTrue(diff < 1e-3   ,			msg=F'''Max diff is {diff}'''			)






    def 		A__      (      self   ,			__lowercase   ,			__lowercase   ,			__lowercase   ,			__lowercase			):
     UpperCAmelCase__ 						=				20
     UpperCAmelCase__ 						=				model_class_name(SCREAMING_SNAKE_CASE_			)

     UpperCAmelCase__ 						=				jnp.concatenate(
         [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])			)]   ,			axis=-1   ,			)

     UpperCAmelCase__ 						=				model.init_cache(input_ids.shape[0]   ,			SCREAMING_SNAKE_CASE_			)
     UpperCAmelCase__ 						=				jnp.broadcast_to(
         jnp.arange(input_ids.shape[-1] - 1			)[None, :]   ,			(input_ids.shape[0], input_ids.shape[-1] - 1)			)

     UpperCAmelCase__ 						=				model(
         input_ids[:, :-1]   ,			attention_mask=SCREAMING_SNAKE_CASE_   ,			past_key_values=SCREAMING_SNAKE_CASE_   ,			position_ids=SCREAMING_SNAKE_CASE_   ,			)
     UpperCAmelCase__ 						=				jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]   ,			dtype="""i4"""			)
     UpperCAmelCase__ 						=				model(
         input_ids[:, -1:]   ,			past_key_values=outputs_cache.past_key_values   ,			attention_mask=SCREAMING_SNAKE_CASE_   ,			position_ids=SCREAMING_SNAKE_CASE_   ,			)

     UpperCAmelCase__ 						=				model(SCREAMING_SNAKE_CASE_   ,			attention_mask=SCREAMING_SNAKE_CASE_			)
     UpperCAmelCase__ 						=				np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
     self.parent.assertTrue(diff < 1e-3   ,			msg=F'''Max diff is {diff}'''			)



@require_sentencepiece
@require_flax
class 	_UpperCamelCase ( lowercase_		,     lowercase_		,     unittest.TestCase							):



    '''simple docstring'''


    __lowercase    :   List[str]											=						(FlaxXGLMModel, FlaxXGLMForCausalLM) if is_flax_available() else ()
    __lowercase    :   Tuple											=						(FlaxXGLMForCausalLM,) if is_flax_available() else ()


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				FlaxXGLMModelTester(self			)


    def 		A__      (      self			):
     for model_class_name in self.all_model_classes:
      UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs()
      self.model_tester.check_use_cache_forward(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			)


    def 		A__      (      self			):
     for model_class_name in self.all_model_classes:
      UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs()
      self.model_tester.check_use_cache_forward_with_attn_mask(
          SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			)


    @slow
    def 		A__      (      self			):
     UpperCAmelCase__ 						=				XGLMTokenizer.from_pretrained("""XGLM"""   ,			padding_side="""left"""			)
     UpperCAmelCase__ 						=				tokenizer(["""Hello this is a long string""", """Hey"""]   ,			return_tensors="""np"""   ,			padding=SCREAMING_SNAKE_CASE_   ,			truncation=SCREAMING_SNAKE_CASE_			)

     UpperCAmelCase__ 						=				FlaxXGLMForCausalLM.from_pretrained("""facebook/xglm-564M"""			)
     UpperCAmelCase__ 						=				1
     UpperCAmelCase__ 						=				False

     UpperCAmelCase__ 						=				jax.jit(model.generate			)

     UpperCAmelCase__ 						=				jit_generate(inputs["""input_ids"""]   ,			attention_mask=inputs["""attention_mask"""]			).sequences

     UpperCAmelCase__ 						=				tokenizer.batch_decode(SCREAMING_SNAKE_CASE_   ,			skip_special_tokens=SCREAMING_SNAKE_CASE_			)

     UpperCAmelCase__ 						=				[
         'Hello this is a long string of questions, but I\'m not sure if I\'m',
         'Hey, I\'m a newbie to the forum and I\'',
     ]

     self.assertListEqual(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			)


    @is_pt_flax_cross_test
    def 		A__      (      self			):
     UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
      with self.subTest(model_class.__name__			):
       # prepare inputs
       UpperCAmelCase__ 						=				self._prepare_for_class(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			)
       UpperCAmelCase__ 						=				{k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

       # load corresponding PyTorch class
       UpperCAmelCase__ 						=				model_class.__name__[4:]  # Skip the "Flax" at the beginning
       UpperCAmelCase__ 						=				getattr(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			)

       UpperCAmelCase__ 						=				pt_inputs['input_ids'].shape
       UpperCAmelCase__ 						=				np.random.randint(0   ,			seq_length - 1   ,			size=(batch_size,)			)
       for batch_idx, start_index in enumerate(SCREAMING_SNAKE_CASE_			):
        UpperCAmelCase__ 						=				0
        UpperCAmelCase__ 						=				1
        UpperCAmelCase__ 						=				0
        UpperCAmelCase__ 						=				1
       UpperCAmelCase__ 						=				pt_model_class(SCREAMING_SNAKE_CASE_			).eval()
       # Flax models don't use the `use_cache` option and cache is not returned as a default.
       # So we disable `use_cache` here for PyTorch model.
       UpperCAmelCase__ 						=				False
       UpperCAmelCase__ 						=				model_class(SCREAMING_SNAKE_CASE_   ,			dtype=jnp.floataa			)
       UpperCAmelCase__ 						=				convert_pytorch_state_dict_to_flax(pt_model.state_dict()   ,			SCREAMING_SNAKE_CASE_			)
       UpperCAmelCase__ 						=				fx_state

       with torch.no_grad():
        UpperCAmelCase__ 						=				pt_model(**SCREAMING_SNAKE_CASE_			).to_tuple()

       UpperCAmelCase__ 						=				fx_model(**SCREAMING_SNAKE_CASE_			).to_tuple()
       self.assertEqual(len(SCREAMING_SNAKE_CASE_			)   ,			len(SCREAMING_SNAKE_CASE_			)   ,			"""Output lengths differ between Flax and PyTorch"""			)
       for fx_output, pt_output in zip(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			):
        self.assert_almost_equals(fx_output[:, -1]   ,			pt_output[:, -1].numpy()   ,			4e-2			)

       with tempfile.TemporaryDirectory() as tmpdirname:
        pt_model.save_pretrained(SCREAMING_SNAKE_CASE_			)
        UpperCAmelCase__ 						=				model_class.from_pretrained(SCREAMING_SNAKE_CASE_   ,			from_pt=SCREAMING_SNAKE_CASE_			)

       UpperCAmelCase__ 						=				fx_model_loaded(**SCREAMING_SNAKE_CASE_			).to_tuple()
       self.assertEqual(
           len(SCREAMING_SNAKE_CASE_			)   ,			len(SCREAMING_SNAKE_CASE_			)   ,			"""Output lengths differ between Flax and PyTorch"""			)
       for fx_output_loaded, pt_output in zip(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			):
        self.assert_almost_equals(fx_output_loaded[:, -1]   ,			pt_output[:, -1].numpy()   ,			4e-2			)


    @is_pt_flax_cross_test
    def 		A__      (      self			):
     UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes:
      with self.subTest(model_class.__name__			):
       # prepare inputs
       UpperCAmelCase__ 						=				self._prepare_for_class(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			)
       UpperCAmelCase__ 						=				{k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

       # load corresponding PyTorch class
       UpperCAmelCase__ 						=				model_class.__name__[4:]  # Skip the "Flax" at the beginning
       UpperCAmelCase__ 						=				getattr(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			)

       UpperCAmelCase__ 						=				pt_model_class(SCREAMING_SNAKE_CASE_			).eval()
       UpperCAmelCase__ 						=				False
       UpperCAmelCase__ 						=				model_class(SCREAMING_SNAKE_CASE_   ,			dtype=jnp.floataa			)

       UpperCAmelCase__ 						=				load_flax_weights_in_pytorch_model(SCREAMING_SNAKE_CASE_   ,			fx_model.params			)
       UpperCAmelCase__ 						=				pt_inputs['input_ids'].shape
       UpperCAmelCase__ 						=				np.random.randint(0   ,			seq_length - 1   ,			size=(batch_size,)			)
       for batch_idx, start_index in enumerate(SCREAMING_SNAKE_CASE_			):
        UpperCAmelCase__ 						=				0
        UpperCAmelCase__ 						=				1
        UpperCAmelCase__ 						=				0
        UpperCAmelCase__ 						=				1

       # make sure weights are tied in PyTorch
       pt_model.tie_weights()

       with torch.no_grad():
        UpperCAmelCase__ 						=				pt_model(**SCREAMING_SNAKE_CASE_			).to_tuple()

       UpperCAmelCase__ 						=				fx_model(**SCREAMING_SNAKE_CASE_			).to_tuple()
       self.assertEqual(len(SCREAMING_SNAKE_CASE_			)   ,			len(SCREAMING_SNAKE_CASE_			)   ,			"""Output lengths differ between Flax and PyTorch"""			)
       for fx_output, pt_output in zip(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			):
        self.assert_almost_equals(fx_output[:, -1]   ,			pt_output[:, -1].numpy()   ,			4e-2			)

       with tempfile.TemporaryDirectory() as tmpdirname:
        fx_model.save_pretrained(SCREAMING_SNAKE_CASE_			)
        UpperCAmelCase__ 						=				pt_model_class.from_pretrained(SCREAMING_SNAKE_CASE_   ,			from_flax=SCREAMING_SNAKE_CASE_			)

       with torch.no_grad():
        UpperCAmelCase__ 						=				pt_model_loaded(**SCREAMING_SNAKE_CASE_			).to_tuple()

       self.assertEqual(
           len(SCREAMING_SNAKE_CASE_			)   ,			len(SCREAMING_SNAKE_CASE_			)   ,			"""Output lengths differ between Flax and PyTorch"""			)
       for fx_output, pt_output in zip(SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_			):
        self.assert_almost_equals(fx_output[:, -1]   ,			pt_output[:, -1].numpy()   ,			4e-2			)






    @slow
    def 		A__      (      self			):
     for model_class_name in self.all_model_classes:
      UpperCAmelCase__ 						=				model_class_name.from_pretrained("""facebook/xglm-564M"""			)
      UpperCAmelCase__ 						=				model(np.ones((1, 1)			)			)
      self.assertIsNotNone(SCREAMING_SNAKE_CASE_			)








"""simple docstring"""







from ..utils import DummyObject, requires_backends







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Any       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[Any]       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: Any			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: int       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: int       ,     *SCREAMING_SNAKE_CASE_							: int       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[Any]       ,     *SCREAMING_SNAKE_CASE_							: str       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: Dict			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: int       ,     *SCREAMING_SNAKE_CASE_							: int       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: str       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Any       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[str]       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: List[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Optional[int]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[int]       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[int]       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: int			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: int       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Union[str, Any]       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[str]       ,     *SCREAMING_SNAKE_CASE_							: int       ,     **SCREAMING_SNAKE_CASE_							: List[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Dict       ,     **SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: Any       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[str]       ,     *SCREAMING_SNAKE_CASE_							: Optional[int]       ,     **SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: str       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: int			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: str       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[int]       ,     *SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: int			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Optional[int]       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[int]       ,     *SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     **SCREAMING_SNAKE_CASE_							: Any			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: int       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Any       ,     **SCREAMING_SNAKE_CASE_							: Dict			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[str]       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: Dict			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Any       ,     *SCREAMING_SNAKE_CASE_							: Dict       ,     **SCREAMING_SNAKE_CASE_							: Dict			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Union[str, Any]       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: Any			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: str       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: int       ,     **SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: Optional[int]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Any       ,     *SCREAMING_SNAKE_CASE_							: Optional[int]       ,     **SCREAMING_SNAKE_CASE_							: Dict			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: Optional[int]       ,     **SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[int]       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Union[str, Any]       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: Any       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: Dict       ,     **SCREAMING_SNAKE_CASE_							: Any			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: int       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[Any]       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: str       ,     *SCREAMING_SNAKE_CASE_							: int       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: str       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[int]       ,     *SCREAMING_SNAKE_CASE_							: Dict       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[str]       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: Any       ,     **SCREAMING_SNAKE_CASE_							: int			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     **SCREAMING_SNAKE_CASE_							: List[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Union[str, Any]       ,     *SCREAMING_SNAKE_CASE_							: str       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: Any       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[str]       ,     *SCREAMING_SNAKE_CASE_							: Optional[int]       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: str       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: Any       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[str]       ,     *SCREAMING_SNAKE_CASE_							: Dict       ,     **SCREAMING_SNAKE_CASE_							: Dict			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: List[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     **SCREAMING_SNAKE_CASE_							: List[Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Any       ,     *SCREAMING_SNAKE_CASE_							: int       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Dict       ,     *SCREAMING_SNAKE_CASE_							: str       ,     **SCREAMING_SNAKE_CASE_							: Tuple			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[Any]       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Any       ,     *SCREAMING_SNAKE_CASE_							: Dict       ,     **SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: str       ,     *SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     **SCREAMING_SNAKE_CASE_							: List[str]			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Tuple       ,     *SCREAMING_SNAKE_CASE_							: List[str]       ,     **SCREAMING_SNAKE_CASE_							: int			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: List[Any]       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: Dict			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: Optional[Any]       ,     *SCREAMING_SNAKE_CASE_							: List[Any]       ,     **SCREAMING_SNAKE_CASE_							: str			):
        requires_backends(self       ,     ['vision']			)







class  UpperCamelCase__  (      metaclass=lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["""vision"""]



      def __init__( self							: str       ,     *SCREAMING_SNAKE_CASE_							: Tuple       ,     **SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        requires_backends(self       ,     ['vision']			)





