





import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


_SCREAMING_SNAKE_CASE   						=		logging.get_logger(__name__)

if is_tf_available():
						import tensorflow as tf
@dataclass
class SCREAMING_SNAKE_CASE_    (       snake_case_       ):
						__magic_name__:      Union[str, Any]			   =							"tf"
						__magic_name__:      Optional[str]			   =							field(
						    default=snake_case_							,					metadata={"help": "Name of TPU"}							,					)

						__magic_name__:      Optional[str]			   =							field(
						    default=snake_case_							,					metadata={"help": "Zone of TPU"}							,					)

						__magic_name__:      Optional[str]			   =							field(
						    default=snake_case_							,					metadata={"help": "Name of Cloud TPU-enabled project"}							,					)

						__magic_name__:      float			   =							field(
						    default=1.0							,					metadata={"help": "Power for the Polynomial decay LR scheduler."}							,					)

						__magic_name__:      bool			   =							field(default=snake_case_							,					metadata={"help": "Whether to activate the XLA compilation or not"}       )






						@cached_property
						def UpperCAmelCase_					(   self   :   List[str]						)				->     Tuple["tf.distribute.Strategy", int]:







							"""simple docstring"""


							requires_backends(self		, ['tf']						)
							logger.info('Tensorflow: setting up strategy'						)

							snake_case_		:      Optional[Any]           =						tf.config.list_physical_devices('GPU'						)

							# Set to float16 at first
							if self.fpaa:
								tf.keras.mixed_precision.set_global_policy('mixed_float16'						)

							if self.no_cuda:
								snake_case_		:      Optional[Any]           =						tf.distribute.OneDeviceStrategy(device='/cpu:0'						)
							else:
								try:
									if self.tpu_name:
										snake_case_		:      int           =						tf.distribute.cluster_resolver.TPUClusterResolver(
										    self.tpu_name		, zone=self.tpu_zone		, project=self.gcp_project						)
									else:
										snake_case_		:      Tuple           =						tf.distribute.cluster_resolver.TPUClusterResolver()
								except ValueError:
									if self.tpu_name:
										raise RuntimeError(F"""Couldn't connect to TPU {self.tpu_name}!"""						)
									else:
										snake_case_		:      Optional[int]           =						None

								if tpu:
									# Set to bfloat16 in case of TPU
									if self.fpaa:
										tf.keras.mixed_precision.set_global_policy('mixed_bfloat16'						)

									tf.config.experimental_connect_to_cluster(_A						)
									tf.tpu.experimental.initialize_tpu_system(_A						)

									snake_case_		:      Optional[int]           =						tf.distribute.TPUStrategy(_A						)

								elif len(_A						) == 0:
									snake_case_		:      int           =						tf.distribute.OneDeviceStrategy(device='/cpu:0'						)
								elif len(_A						) == 1:
									snake_case_		:      Optional[int]           =						tf.distribute.OneDeviceStrategy(device='/gpu:0'						)
								elif len(_A						) > 1:
									# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
									snake_case_		:      List[str]           =						tf.distribute.MirroredStrategy()
								else:
									raise ValueError('Cannot find the proper strategy, please check your environment properties.'						)

							return strategy






						@property
						def UpperCAmelCase_					(   self   :   List[Any]						)				->     "tf.distribute.Strategy":







							"""simple docstring"""


							requires_backends(self		, ['tf']						)
							return self._setup_strategy






						@property
						def UpperCAmelCase_					(   self   :   Dict						)				->     int:







							"""simple docstring"""


							requires_backends(self		, ['tf']						)
							return self._setup_strategy.num_replicas_in_sync






						@property
						def UpperCAmelCase_					(   self   :   int						)				->     Optional[int]:







							"""simple docstring"""


							return False  # TF Logging is handled by Keras not the Trainer






						@property
						def UpperCAmelCase_					(   self   :   List[Any]						)				->     int:







							"""simple docstring"""


							if self.per_gpu_train_batch_size:
								logger.warning(
								    'Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future '
								    'version. Using `--per_device_train_batch_size` is preferred.'						)
							snake_case_		:      Optional[int]           =						self.per_gpu_train_batch_size or self.per_device_train_batch_size
							return per_device_batch_size * self.n_replicas






						@property
						def UpperCAmelCase_					(   self   :   List[str]						)				->     int:







							"""simple docstring"""


							if self.per_gpu_eval_batch_size:
								logger.warning(
								    'Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future '
								    'version. Using `--per_device_eval_batch_size` is preferred.'						)
							snake_case_		:      Any           =						self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
							return per_device_batch_size * self.n_replicas






						@property
						def UpperCAmelCase_					(   self   :   Optional[int]						)				->     int:







							"""simple docstring"""


							requires_backends(self		, ['tf']						)
							warnings.warn(
							    'The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.'		, _A		, )
							return self._setup_strategy.num_replicas_in_sync



'''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''']   )

