





"""simple docstring"""






import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import MODEL_MAPPING, GLPNConfig, GLPNForDepthEstimation, GLPNModel
    from transformers.models.glpn.modeling_glpn import GLPN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import GLPNImageProcessor



class 						lowerCAmelCase       (   snake_case				):






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.config_class(**self.inputs_dict  )
              self.parent.assertTrue(hasattr(a__     ,	'hidden_sizes'  )  )
              self.parent.assertTrue(hasattr(a__     ,	'num_attention_heads'  )  )
              self.parent.assertTrue(hasattr(a__     ,	'num_encoder_blocks'  )  )



class 						lowerCAmelCase       :






       def __init__( self     ,	a__     ,	a__=13     ,	a__=64     ,	a__=3     ,	a__=4     ,	a__=[2, 2, 2, 2]     ,	a__=[8, 4, 2, 1]     ,	a__=[16, 32, 64, 1_28]     ,	a__=[1, 4, 8, 16]     ,	a__=[1, 2, 4, 8]     ,	a__=True     ,	a__=True     ,	a__="gelu"     ,	a__=0.1     ,	a__=0.1     ,	a__=0.02     ,	a__=16     ,	a__=3     ,	a__=None     ,	):
              _UpperCAmelCase			     =  parent
              _UpperCAmelCase			     =  batch_size
              _UpperCAmelCase			     =  image_size
              _UpperCAmelCase			     =  num_channels
              _UpperCAmelCase			     =  num_encoder_blocks
              _UpperCAmelCase			     =  sr_ratios
              _UpperCAmelCase			     =  depths
              _UpperCAmelCase			     =  hidden_sizes
              _UpperCAmelCase			     =  downsampling_rates
              _UpperCAmelCase			     =  num_attention_heads
              _UpperCAmelCase			     =  is_training
              _UpperCAmelCase			     =  use_labels
              _UpperCAmelCase			     =  hidden_act
              _UpperCAmelCase			     =  hidden_dropout_prob
              _UpperCAmelCase			     =  attention_probs_dropout_prob
              _UpperCAmelCase			     =  initializer_range
              _UpperCAmelCase			     =  decoder_hidden_size
              _UpperCAmelCase			     =  num_labels
              _UpperCAmelCase			     =  scope






       def 				__A			( self  ):
              _UpperCAmelCase			     =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

              _UpperCAmelCase			     =  None
              if self.use_labels:
                     _UpperCAmelCase			     =  ids_tensor([self.batch_size, self.image_size, self.image_size]     ,	self.num_labels  )

              _UpperCAmelCase			     =  self.get_config()
              return config, pixel_values, labels






       def 				__A			( self  ):
              return GLPNConfig(
                  image_size=self.image_size     ,	num_channels=self.num_channels     ,	num_encoder_blocks=self.num_encoder_blocks     ,	depths=self.depths     ,	hidden_sizes=self.hidden_sizes     ,	num_attention_heads=self.num_attention_heads     ,	hidden_act=self.hidden_act     ,	hidden_dropout_prob=self.hidden_dropout_prob     ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,	initializer_range=self.initializer_range     ,	decoder_hidden_size=self.decoder_hidden_size     ,	)






       def 				__A			( self     ,	a__     ,	a__     ,	a__  ):
              _UpperCAmelCase			     =  GLPNModel(config=a__  )
              model.to(a__  )
              model.eval()
              _UpperCAmelCase			     =  model(a__  )
              _UpperCAmelCase			     =  self.image_size // (self.downsampling_rates[-1] * 2)
              self.parent.assertEqual(
                  result.last_hidden_state.shape     ,	(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)  )






       def 				__A			( self     ,	a__     ,	a__     ,	a__  ):
              _UpperCAmelCase			     =  self.num_labels
              _UpperCAmelCase			     =  GLPNForDepthEstimation(a__  )
              model.to(a__  )
              model.eval()
              _UpperCAmelCase			     =  model(a__  )
              self.parent.assertEqual(result.predicted_depth.shape     ,	(self.batch_size, self.image_size, self.image_size)  )
              _UpperCAmelCase			     =  model(a__     ,	labels=a__  )
              self.parent.assertEqual(result.predicted_depth.shape     ,	(self.batch_size, self.image_size, self.image_size)  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.prepare_config_and_inputs()
              _UpperCAmelCase			     =  config_and_inputs
              _UpperCAmelCase			     =  {"""pixel_values""": pixel_values}
              return config, inputs_dict



@require_torch
class 						lowerCAmelCase       (   snake_case      ,						snake_case      ,						unittest.TestCase				):
       lowerCAmelCase__    			=	(GLPNModel, GLPNForDepthEstimation) if is_torch_available() else ()
       lowerCAmelCase__    			=	(
           {"""depth-estimation""": GLPNForDepthEstimation, """feature-extraction""": GLPNModel} if is_torch_available() else {}
       )

       lowerCAmelCase__    			=	False
       lowerCAmelCase__    			=	False
       lowerCAmelCase__    			=	False






       def 				__A			( self  ):
              _UpperCAmelCase			     =  GLPNModelTester(self  )
              _UpperCAmelCase			     =  GLPNConfigTester(self     ,	config_class=a__  )






       def 				__A			( self  ):
              self.config_tester.run_common_tests()






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_depth_estimation(*a__  )






       @unittest.skip('GLPN does not use inputs_embeds'  )
       def 				__A			( self  ):
              pass






       @unittest.skip('GLPN does not have get_input_embeddings method and get_output_embeddings methods'  )
       def 				__A			( self  ):
              pass






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     _UpperCAmelCase			     =  inspect.signature(model.forward  )
                     # signature.parameters is an OrderedDict => so arg_names order is deterministic
                     _UpperCAmelCase			     =  [*signature.parameters.keys()]

                     _UpperCAmelCase			     =  ["""pixel_values"""]
                     self.assertListEqual(arg_names[:1]     ,	a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()
              _UpperCAmelCase			     =  True

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  True
                     _UpperCAmelCase			     =  False
                     _UpperCAmelCase			     =  True
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     with torch.no_grad():
                            _UpperCAmelCase			     =  model(**self._prepare_for_class(a__     ,	a__  )  )
                     _UpperCAmelCase			     =  outputs.attentions

                     _UpperCAmelCase			     =  sum(self.model_tester.depths  )
                     self.assertEqual(len(a__  )     ,	a__  )

                     # check that output_attentions also work using config
                     del inputs_dict["output_attentions"]
                     _UpperCAmelCase			     =  True
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     with torch.no_grad():
                            _UpperCAmelCase			     =  model(**self._prepare_for_class(a__     ,	a__  )  )
                     _UpperCAmelCase			     =  outputs.attentions

                     self.assertEqual(len(a__  )     ,	a__  )

                     # verify the first attentions (first block, first layer)
                     _UpperCAmelCase			     =  (self.model_tester.image_size // 4) ** 2
                     _UpperCAmelCase			     =  (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
                     self.assertListEqual(
                         list(attentions[0].shape[-3:]  )     ,	[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]     ,	)

                     # verify the last attentions (last block, last layer)
                     _UpperCAmelCase			     =  (self.model_tester.image_size // 32) ** 2
                     _UpperCAmelCase			     =  (self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
                     self.assertListEqual(
                         list(attentions[-1].shape[-3:]  )     ,	[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]     ,	)
                     _UpperCAmelCase			     =  len(a__  )

                     # Check attention is always last and order is fine
                     _UpperCAmelCase			     =  True
                     _UpperCAmelCase			     =  True
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     with torch.no_grad():
                            _UpperCAmelCase			     =  model(**self._prepare_for_class(a__     ,	a__  )  )

                     self.assertEqual(out_len + 1     ,	len(a__  )  )

                     _UpperCAmelCase			     =  outputs.attentions

                     self.assertEqual(len(a__  )     ,	a__  )
                     # verify the first attentions (first block, first layer)
                     _UpperCAmelCase			     =  (self.model_tester.image_size // 4) ** 2
                     _UpperCAmelCase			     =  (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
                     self.assertListEqual(
                         list(self_attentions[0].shape[-3:]  )     ,	[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]     ,	)






       def 				__A			( self  ):
              def check_hidden_states_output(a__     ,	a__     ,	a__  ):
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()

                     with torch.no_grad():
                            _UpperCAmelCase			     =  model(**self._prepare_for_class(a__     ,	a__  )  )

                     _UpperCAmelCase			     =  outputs.hidden_states

                     _UpperCAmelCase			     =  self.model_tester.num_encoder_blocks
                     self.assertEqual(len(a__  )     ,	a__  )

                     # verify the first hidden states (first block)
                     self.assertListEqual(
                         list(hidden_states[0].shape[-3:]  )     ,	[
                             self.model_tester.hidden_sizes[0],
                             self.model_tester.image_size // 4,
                             self.model_tester.image_size // 4,
                         ]     ,	)

              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  True
                     check_hidden_states_output(a__     ,	a__     ,	a__  )

                     # check that output_hidden_states also work using config
                     del inputs_dict["output_hidden_states"]
                     _UpperCAmelCase			     =  True

                     check_hidden_states_output(a__     ,	a__     ,	a__  )






       def 				__A			( self  ):
              if not self.model_tester.is_training:
                     return

              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()
              _UpperCAmelCase			     =  True

              for model_class in self.all_model_classes:
                     if model_class in get_values(a__  ):
                            continue
                     # TODO: remove the following 3 lines once we have a MODEL_FOR_DEPTH_ESTIMATION_MAPPING
                     # this can then be incorporated into _prepare_for_class in test_modeling_common.py
                     if model_class.__name__ == "GLPNForDepthEstimation":
                            _UpperCAmelCase			     =  inputs_dict["""pixel_values"""].shape
                            _UpperCAmelCase			     =  torch.zeros(
                                [self.model_tester.batch_size, height, width]     ,	device=a__  ).long()
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.train()
                     _UpperCAmelCase			     =  self._prepare_for_class(a__     ,	a__     ,	return_labels=a__  )
                     _UpperCAmelCase			     =  model(**a__  ).loss
                     loss.backward()






       @slow
       def 				__A			( self  ):
              for model_name in GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     _UpperCAmelCase			     =  GLPNModel.from_pretrained(a__  )
                     self.assertIsNotNone(a__  )


def    __lowerCamelCase     (							)		->							Optional[Any]:






       """simple docstring"""




       _UpperCAmelCase			     =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
       return image



@require_torch
@require_vision
@slow
class 						lowerCAmelCase       (   unittest.TestCase				):






       @slow
       def 				__A			( self  ):
              _UpperCAmelCase			     =  GLPNImageProcessor.from_pretrained(GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )
              _UpperCAmelCase			     =  GLPNForDepthEstimation.from_pretrained(GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[0]  ).to(a__  )

              _UpperCAmelCase			     =  prepare_img()
              _UpperCAmelCase			     =  image_processor(images=a__     ,	return_tensors='pt'  ).to(a__  )

              # forward pass
              with torch.no_grad():
                     _UpperCAmelCase			     =  model(**a__  )

              # verify the predicted depth
              _UpperCAmelCase			     =  torch.Size([1, 4_80, 6_40]  )
              self.assertEqual(outputs.predicted_depth.shape     ,	a__  )

              _UpperCAmelCase			     =  torch.tensor(
                  [[3.4_291, 2.7_865, 2.5_151], [3.2_841, 2.7_021, 2.3_502], [3.1_147, 2.4_625, 2.2_481]]  ).to(a__  )

              self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]     ,	a__     ,	atol=1E-4  )  )










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







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[Any]						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					str					, **lowerCamelCase	:					int						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Any						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					str						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					str						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[int]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Dict						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					List[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[int]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					Dict						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					int						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[str]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Tuple						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					int						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					List[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Any						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Tuple						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Union[str, Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Tuple						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Union[str, Any]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Union[str, Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					str						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					Union[str, Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Optional[int]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					int					, **lowerCamelCase	:					Optional[Any]						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					int						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Any						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					int						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					str					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					List[Any]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					str						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					int						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					int						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Union[str, Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					int					, **lowerCamelCase	:					Dict						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Optional[int]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Any						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[Any]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Any						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Union[str, Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Optional[int]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					str					, **lowerCamelCase	:					Tuple						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					List[Any]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Union[str, Any]						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[str]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Optional[int]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Dict						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[int]						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Tuple						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)




