
'''simple docstring'''





import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import SegformerImageProcessor

class     a (					unittest.TestCase     ):




				def __init__(				self						:					Dict,     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					List[str]=7,     SCREAMING_SNAKE_CASE_						:					Tuple=3,     SCREAMING_SNAKE_CASE_						:					Union[str, Any]=30,     SCREAMING_SNAKE_CASE_						:					Optional[int]=4_00,     SCREAMING_SNAKE_CASE_						:					Optional[Any]=True,     SCREAMING_SNAKE_CASE_						:					Optional[Any]=None,     SCREAMING_SNAKE_CASE_						:					List[Any]=True,     SCREAMING_SNAKE_CASE_						:					Dict=[0.5, 0.5, 0.5],     SCREAMING_SNAKE_CASE_						:					Dict=[0.5, 0.5, 0.5],     SCREAMING_SNAKE_CASE_						:					Optional[int]=False,     ):
										snake_case							:  Any			=     size if size is not None else {'''height''': 30, '''width''': 30}
										snake_case							:  Optional[Any]			=     parent
										snake_case							:  Dict			=     batch_size
										snake_case							:  List[Any]			=     num_channels
										snake_case							:  Union[str, Any]			=     min_resolution
										snake_case							:  Tuple			=     max_resolution
										snake_case							:  Tuple			=     do_resize
										snake_case							:  Dict			=     size
										snake_case							:  Any			=     do_normalize
										snake_case							:  int			=     image_mean
										snake_case							:  Union[str, Any]			=     image_std
										snake_case							:  Optional[Any]			=     do_reduce_labels




				def 						__snake_case				(				self						:					str   ):
										return {
										    "do_resize": self.do_resize,
										    "size": self.size,
										    "do_normalize": self.do_normalize,
										    "image_mean": self.image_mean,
										    "image_std": self.image_std,
										    "do_reduce_labels": self.do_reduce_labels,
										}




def   A			(							):
						snake_case							:  Union[str, Any]			=     load_dataset('''hf-internal-testing/fixtures_ade20k'''     ,				split='''test'''							)

						snake_case							:  Optional[int]			=     Image.open(dataset[0]['''file''']							)
						snake_case							:  Any			=     Image.open(dataset[1]['''file''']							)

						return image, map

def   A			(							):
						snake_case							:  Any			=     load_dataset('''hf-internal-testing/fixtures_ade20k'''     ,				split='''test'''							)

						snake_case							:  Union[str, Any]			=     Image.open(dataset[0]['''file''']							)
						snake_case							:  List[str]			=     Image.open(dataset[1]['''file''']							)
						snake_case							:  List[Any]			=     Image.open(dataset[2]['''file''']							)
						snake_case							:  Dict			=     Image.open(dataset[3]['''file''']							)

						return [imagea, imagea], [mapa, mapa]





@require_torch
@require_vision
class     a (					__magic_name__					,unittest.TestCase     ):
				_snake_case		     =			SegformerImageProcessor if is_vision_available() else None




				def 						__snake_case				(				self						:					str   ):
										snake_case							:  List[str]			=     SegformerImageProcessingTester(self   )




				@property
				def 						__snake_case				(				self						:					Dict   ):
										return self.image_processor_tester.prepare_image_processor_dict()




				def 						__snake_case				(				self						:					int   ):
										snake_case							:  List[str]			=     self.image_processing_class(**self.image_processor_dict   )
										self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,     '''do_resize'''   )   )
										self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,     '''size'''   )   )
										self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,     '''do_normalize'''   )   )
										self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,     '''image_mean'''   )   )
										self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,     '''image_std'''   )   )
										self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,     '''do_reduce_labels'''   )   )




				def 						__snake_case				(				self						:					List[Any]   ):
										snake_case							:  Union[str, Any]			=     self.image_processing_class.from_dict(self.image_processor_dict   )
										self.assertEqual(image_processor.size,     {'''height''': 30, '''width''': 30}   )
										self.assertEqual(image_processor.do_reduce_labels,     SCREAMING_SNAKE_CASE_   )

										snake_case							:  Optional[Any]			=     self.image_processing_class.from_dict(self.image_processor_dict,     size=42,     reduce_labels=SCREAMING_SNAKE_CASE_   )
										self.assertEqual(image_processor.size,     {'''height''': 42, '''width''': 42}   )
										self.assertEqual(image_processor.do_reduce_labels,     SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					Any   ):
										pass




				def 						__snake_case				(				self						:					Tuple   ):
										# Initialize image_processing
										snake_case							:  str			=     self.image_processing_class(**self.image_processor_dict   )
										# create random PIL images
										snake_case							:  Dict			=     prepare_image_inputs(self.image_processor_tester,     equal_resolution=SCREAMING_SNAKE_CASE_   )
										for image in image_inputs:
																self.assertIsInstance(SCREAMING_SNAKE_CASE_,     Image.Image   )

										# Test not batched input
										snake_case							:  List[str]			=     image_processing(image_inputs[0],     return_tensors='''pt'''   ).pixel_values
										self.assertEqual(
										    encoded_images.shape,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )

										# Test batched
										snake_case							:  int			=     image_processing(SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   ).pixel_values
										self.assertEqual(
										    encoded_images.shape,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )




				def 						__snake_case				(				self						:					Tuple   ):
										# Initialize image_processing
										snake_case							:  Optional[Any]			=     self.image_processing_class(**self.image_processor_dict   )
										# create random numpy tensors
										snake_case							:  List[Any]			=     prepare_image_inputs(self.image_processor_tester,     equal_resolution=SCREAMING_SNAKE_CASE_,     numpify=SCREAMING_SNAKE_CASE_   )
										for image in image_inputs:
																self.assertIsInstance(SCREAMING_SNAKE_CASE_,     np.ndarray   )

										# Test not batched input
										snake_case							:  Optional[int]			=     image_processing(image_inputs[0],     return_tensors='''pt'''   ).pixel_values
										self.assertEqual(
										    encoded_images.shape,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )

										# Test batched
										snake_case							:  Optional[Any]			=     image_processing(SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   ).pixel_values
										self.assertEqual(
										    encoded_images.shape,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )




				def 						__snake_case				(				self						:					int   ):
										# Initialize image_processing
										snake_case							:  Any			=     self.image_processing_class(**self.image_processor_dict   )
										# create random PyTorch tensors
										snake_case							:  Optional[int]			=     prepare_image_inputs(self.image_processor_tester,     equal_resolution=SCREAMING_SNAKE_CASE_,     torchify=SCREAMING_SNAKE_CASE_   )
										for image in image_inputs:
																self.assertIsInstance(SCREAMING_SNAKE_CASE_,     torch.Tensor   )

										# Test not batched input
										snake_case							:  int			=     image_processing(image_inputs[0],     return_tensors='''pt'''   ).pixel_values
										self.assertEqual(
										    encoded_images.shape,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )

										# Test batched
										snake_case							:  Tuple			=     image_processing(SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   ).pixel_values
										self.assertEqual(
										    encoded_images.shape,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )




				def 						__snake_case				(				self						:					List[str]   ):
										# Initialize image_processing
										snake_case							:  Tuple			=     self.image_processing_class(**self.image_processor_dict   )
										# create random PyTorch tensors
										snake_case							:  Tuple			=     prepare_image_inputs(self.image_processor_tester,     equal_resolution=SCREAMING_SNAKE_CASE_,     torchify=SCREAMING_SNAKE_CASE_   )
										snake_case							:  str			=     []
										for image in image_inputs:
																self.assertIsInstance(SCREAMING_SNAKE_CASE_,     torch.Tensor   )
																maps.append(torch.zeros(image.shape[-2:]   ).long()   )

										# Test not batched input
										snake_case							:  int			=     image_processing(image_inputs[0],     maps[0],     return_tensors='''pt'''   )
										self.assertEqual(
										    encoding['''pixel_values'''].shape,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(
										    encoding['''labels'''].shape,     (
										        1,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(encoding['''labels'''].dtype,     torch.long   )
										self.assertTrue(encoding['''labels'''].min().item() >= 0   )
										self.assertTrue(encoding['''labels'''].max().item() <= 2_55   )

										# Test batched
										snake_case							:  Any			=     image_processing(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   )
										self.assertEqual(
										    encoding['''pixel_values'''].shape,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(
										    encoding['''labels'''].shape,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(encoding['''labels'''].dtype,     torch.long   )
										self.assertTrue(encoding['''labels'''].min().item() >= 0   )
										self.assertTrue(encoding['''labels'''].max().item() <= 2_55   )

										# Test not batched input (PIL images)
										snake_case,       snake_case							:  Tuple			=     prepare_semantic_single_inputs()

										snake_case							:  int			=     image_processing(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   )
										self.assertEqual(
										    encoding['''pixel_values'''].shape,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(
										    encoding['''labels'''].shape,     (
										        1,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(encoding['''labels'''].dtype,     torch.long   )
										self.assertTrue(encoding['''labels'''].min().item() >= 0   )
										self.assertTrue(encoding['''labels'''].max().item() <= 2_55   )

										# Test batched input (PIL images)
										snake_case,       snake_case							:  int			=     prepare_semantic_batch_inputs()

										snake_case							:  List[str]			=     image_processing(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   )
										self.assertEqual(
										    encoding['''pixel_values'''].shape,     (
										        2,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(
										    encoding['''labels'''].shape,     (
										        2,
										        self.image_processor_tester.size['''height'''],
										        self.image_processor_tester.size['''width'''],
										    ),     )
										self.assertEqual(encoding['''labels'''].dtype,     torch.long   )
										self.assertTrue(encoding['''labels'''].min().item() >= 0   )
										self.assertTrue(encoding['''labels'''].max().item() <= 2_55   )




				def 						__snake_case				(				self						:					Tuple   ):
										# Initialize image_processing
										snake_case							:  int			=     self.image_processing_class(**self.image_processor_dict   )

										# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
										snake_case,       snake_case							:  Dict			=     prepare_semantic_single_inputs()
										snake_case							:  Optional[int]			=     image_processing(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   )
										self.assertTrue(encoding['''labels'''].min().item() >= 0   )
										self.assertTrue(encoding['''labels'''].max().item() <= 1_50   )

										snake_case							:  int			=     True
										snake_case							:  Optional[int]			=     image_processing(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     return_tensors='''pt'''   )
										self.assertTrue(encoding['''labels'''].min().item() >= 0   )
										self.assertTrue(encoding['''labels'''].max().item() <= 2_55   )



'''simple docstring'''





from ..utils import DummyObject, requires_backends

class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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




class     a (					metaclass=__magic_name__     ):
				_snake_case		     =			['''vision''']




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

