

from __future__ import annotations

import unittest

from transformers import AlbertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import TF_MODEL_FOR_PRETRAINING_MAPPING
					from transformers.models.albert.modeling_tf_albert import (
					    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TFAlbertForMaskedLM,
					    TFAlbertForMultipleChoice,
					    TFAlbertForPreTraining,
					    TFAlbertForQuestionAnswering,
					    TFAlbertForSequenceClassification,
					    TFAlbertForTokenClassification,
					    TFAlbertModel,
					)

class  a     :


						def __init__(				self  ,    A_  ,    A_=13  ,    A_=7  ,    A_=True  ,    A_=True  ,    A_=True  ,    A_=True  ,    A_=99  ,    A_=16  ,    A_=32  ,    A_=2  ,    A_=4  ,    A_=37  ,    A_="gelu"  ,    A_=0.1  ,    A_=0.1  ,    A_=512  ,    A_=16  ,    A_=2  ,    A_=0.02  ,    A_=3  ,    A_=4  ,    A_=None  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			parent
										_UpperCAmelCase				:						List[Any]       						=			13
										_UpperCAmelCase				:						Any       						=			7
										_UpperCAmelCase				:						List[Any]       						=			True
										_UpperCAmelCase				:						Optional[Any]       						=			True
										_UpperCAmelCase				:						Dict       						=			True
										_UpperCAmelCase				:						Union[str, Any]       						=			True
										_UpperCAmelCase				:						List[str]       						=			99
										_UpperCAmelCase				:						Optional[int]       						=			16
										_UpperCAmelCase				:						Union[str, Any]       						=			32
										_UpperCAmelCase				:						Union[str, Any]       						=			2
										_UpperCAmelCase				:						Optional[Any]       						=			4
										_UpperCAmelCase				:						Dict       						=			37
										_UpperCAmelCase				:						Tuple       						=			"gelu"
										_UpperCAmelCase				:						Optional[int]       						=			0.1
										_UpperCAmelCase				:						int       						=			0.1
										_UpperCAmelCase				:						Dict       						=			512
										_UpperCAmelCase				:						List[str]       						=			16
										_UpperCAmelCase				:						Tuple       						=			2
										_UpperCAmelCase				:						Optional[int]       						=			0.02
										_UpperCAmelCase				:						List[Any]       						=			3
										_UpperCAmelCase				:						int       						=			4
										_UpperCAmelCase				:						Optional[Any]       						=			None


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			ids_tensor([self.batch_size, self.seq_length]  ,    self.vocab_size		)

										_UpperCAmelCase				:						List[Any]       						=			None
										if self.use_input_mask:
														_UpperCAmelCase				:						Optional[int]       						=			random_attention_mask([self.batch_size, self.seq_length]		)

										_UpperCAmelCase				:						int       						=			None
										if self.use_token_type_ids:
														_UpperCAmelCase				:						Optional[int]       						=			ids_tensor([self.batch_size, self.seq_length]  ,    self.type_vocab_size		)

										_UpperCAmelCase				:						List[str]       						=			None
										_UpperCAmelCase				:						Tuple       						=			None
										_UpperCAmelCase				:						Any       						=			None
										if self.use_labels:
														_UpperCAmelCase				:						Optional[Any]       						=			ids_tensor([self.batch_size]  ,    self.type_sequence_label_size		)
														_UpperCAmelCase				:						Dict       						=			ids_tensor([self.batch_size, self.seq_length]  ,    self.num_labels		)
														_UpperCAmelCase				:						Union[str, Any]       						=			ids_tensor([self.batch_size]  ,    self.num_choices		)

										_UpperCAmelCase				:						str       						=			AlbertConfig(
										    vocab_size=self.vocab_size  ,    hidden_size=self.hidden_size  ,    embedding_size=self.embedding_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  ,    max_position_embeddings=self.max_position_embeddings  ,    type_vocab_size=self.type_vocab_size  ,    initializer_range=self.initializer_range  ,    )

										return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[Any]       						=			TFAlbertModel(config=lowerCamelCase__		)
										# inputs = {'input_ids': input_ids,
										#           'attention_mask': input_mask,
										#           'token_type_ids': token_type_ids}
										# sequence_output, pooled_output = model(**inputs)
										_UpperCAmelCase				:						Any       						=			{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										_UpperCAmelCase				:						Any       						=			model(lowerCamelCase__		)

										_UpperCAmelCase				:						Optional[Any]       						=			[input_ids, input_mask]
										_UpperCAmelCase				:						str       						=			model(lowerCamelCase__		)

										_UpperCAmelCase				:						str       						=			model(lowerCamelCase__		)

										self.parent.assertEqual(result.last_hidden_state.shape  ,    (self.batch_size, self.seq_length, self.hidden_size)		)
										self.parent.assertEqual(result.pooler_output.shape  ,    (self.batch_size, self.hidden_size)		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			self.num_labels
										_UpperCAmelCase				:						Optional[Any]       						=			TFAlbertForPreTraining(config=lowerCamelCase__		)
										_UpperCAmelCase				:						int       						=			{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										_UpperCAmelCase				:						Tuple       						=			model(lowerCamelCase__		)
										self.parent.assertEqual(result.prediction_logits.shape  ,    (self.batch_size, self.seq_length, self.vocab_size)		)
										self.parent.assertEqual(result.sop_logits.shape  ,    (self.batch_size, self.num_labels)		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[int]       						=			TFAlbertForMaskedLM(config=lowerCamelCase__		)
										_UpperCAmelCase				:						str       						=			{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										_UpperCAmelCase				:						Union[str, Any]       						=			model(lowerCamelCase__		)
										self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.seq_length, self.vocab_size)		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Dict       						=			self.num_labels
										_UpperCAmelCase				:						Tuple       						=			TFAlbertForSequenceClassification(config=lowerCamelCase__		)
										_UpperCAmelCase				:						str       						=			{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										_UpperCAmelCase				:						List[Any]       						=			model(lowerCamelCase__		)
										self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.num_labels)		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						int       						=			TFAlbertForQuestionAnswering(config=lowerCamelCase__		)
										_UpperCAmelCase				:						Dict       						=			{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										_UpperCAmelCase				:						List[str]       						=			model(lowerCamelCase__		)
										self.parent.assertEqual(result.start_logits.shape  ,    (self.batch_size, self.seq_length)		)
										self.parent.assertEqual(result.end_logits.shape  ,    (self.batch_size, self.seq_length)		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			self.num_choices
										_UpperCAmelCase				:						int       						=			TFAlbertForMultipleChoice(config=lowerCamelCase__		)
										_UpperCAmelCase				:						Union[str, Any]       						=			tf.tile(tf.expand_dims(lowerCamelCase__  ,    1		)  ,    (1, self.num_choices, 1)		)
										_UpperCAmelCase				:						List[Any]       						=			tf.tile(tf.expand_dims(lowerCamelCase__  ,    1		)  ,    (1, self.num_choices, 1)		)
										_UpperCAmelCase				:						Dict       						=			tf.tile(tf.expand_dims(lowerCamelCase__  ,    1		)  ,    (1, self.num_choices, 1)		)
										_UpperCAmelCase				:						Optional[int]       						=			{
										    "input_ids": multiple_choice_inputs_ids,
										    "attention_mask": multiple_choice_input_mask,
										    "token_type_ids": multiple_choice_token_type_ids,
										}
										_UpperCAmelCase				:						Tuple       						=			model(lowerCamelCase__		)
										self.parent.assertListEqual(list(result["logits"].shape		)  ,    [self.batch_size, self.num_choices]		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Any       						=			self.num_labels
										_UpperCAmelCase				:						Optional[Any]       						=			TFAlbertForTokenClassification(config=lowerCamelCase__		)
										_UpperCAmelCase				:						Any       						=			{
										    "input_ids": input_ids,
										    "attention_mask": input_mask,
										    "token_type_ids": token_type_ids,
										}
										_UpperCAmelCase				:						int       						=			model(lowerCamelCase__		)
										self.parent.assertListEqual(list(result["logits"].shape		)  ,    [self.batch_size, self.seq_length, self.num_labels]		)





						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			self.prepare_config_and_inputs()
										(
										    (
										    _UpperCAmelCase   
										)						,							(
										    _UpperCAmelCase   
										)						,							(
										    _UpperCAmelCase   
										)						,							(
										    _UpperCAmelCase   
										)						,							(
										    _UpperCAmelCase   
										)						,							(
										    _UpperCAmelCase   
										)						,							(
										    _UpperCAmelCase   
										)						,							   
										)				:						Optional[int]       						=			config_and_inputs
										_UpperCAmelCase				:						int       						=			{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
										return config, inputs_dict







@require_tf
class  a     (		A__							,       A__							,       unittest.TestCase ):
						_lowercase			  =	(
						    (
						        TFAlbertModel,
						        TFAlbertForPreTraining,
						        TFAlbertForMaskedLM,
						        TFAlbertForSequenceClassification,
						        TFAlbertForQuestionAnswering,
						        TFAlbertForTokenClassification,
						        TFAlbertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						_lowercase			  =	(
						    {
						        'feature-extraction': TFAlbertModel,
						        'fill-mask': TFAlbertForMaskedLM,
						        'question-answering': TFAlbertForQuestionAnswering,
						        'text-classification': TFAlbertForSequenceClassification,
						        'token-classification': TFAlbertForTokenClassification,
						        'zero-shot': TFAlbertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						_lowercase			  =	False
						_lowercase			  =	False


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_=False		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			super()._prepare_for_class(lowerCamelCase__  ,    lowerCamelCase__  ,    return_labels=lowerCamelCase__		)

										if return_labels:
														if model_class in get_values(lowerCamelCase__		):
																		_UpperCAmelCase				:						Optional[int]       						=			tf.zeros(self.model_tester.batch_size  ,    dtype=tf.intaa		)

										return inputs_dict


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			TFAlbertModelTester(self		)
										_UpperCAmelCase				:						Any       						=			ConfigTester(self  ,    config_class=lowerCamelCase__  ,    hidden_size=37		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										self.config_tester.run_common_tests()


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Dict       						=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_albert_model(*lowerCamelCase__		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_albert_for_pretraining(*lowerCamelCase__		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[Any]       						=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_albert_for_masked_lm(*lowerCamelCase__		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						int       						=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_albert_for_multiple_choice(*lowerCamelCase__		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_albert_for_sequence_classification(*lowerCamelCase__		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[Any]       						=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_albert_for_question_answering(*lowerCamelCase__		)





						@slow
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_UpperCAmelCase				:						Dict       						=			TFAlbertModel.from_pretrained(lowerCamelCase__		)
														self.assertIsNotNone(lowerCamelCase__		)







@require_tf
class  a     (		unittest.TestCase ):


						@slow
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			TFAlbertForPreTraining.from_pretrained("albert-base-v2"		)
										_UpperCAmelCase				:						List[str]       						=			tf.constant([[0, 1, 2, 3, 4, 5]]		)
										_UpperCAmelCase				:						List[Any]       						=			model(lowerCamelCase__		)[0]

										_UpperCAmelCase				:						Dict       						=			[1, 6, 30000]
										self.assertEqual(output.shape  ,    lowerCamelCase__		)

										_UpperCAmelCase				:						Tuple       						=			tf.constant(
										    [
										        [
										            [4.59_56_68, 0.74_46_27_54, -1.81_81_47],
										            [4.5_95_43_47, 0.7_45_41_84, -1.8_18_82_58],
										            [4.5_95_49_05, 0.7_44_82_35, -1.8_18_23_16],
										        ]
										    ]		)
										tf.debugging.assert_near(output[:, :3, :3]  ,    lowerCamelCase__  ,    atol=1e-4		)







"""simple docstring"""
from ..utils import DummyObject, requires_backends


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Dict        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Tuple        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Tuple        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[int]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[int]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Dict        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Tuple        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[int]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[int]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Any        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Dict        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[int]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Dict        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[int]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Dict        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Dict        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Tuple        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				int        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Dict        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Optional[int]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				str        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				List[str]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )


class 							lowerCamelCase_(      metaclass=A__			):





					'''simple docstring'''



					lowercase__      :				Union[str, Any]        =       ['vision']

					def __init__(			self ,				*lowerCamelCase__ ,				**lowerCamelCase__      ):
									requires_backends(self ,				['''vision''']      )
