"""simple docstring"""




from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
     import tensorflow as tf


_a   :	int 					=     logging.get_logger(__name__)
@dataclass
class 		__A							(				SCREAMING_SNAKE_CASE_	):
     _UpperCamelCase							:    Any	      =	[
         "no_inference",
         "no_cuda",
         "no_tpu",
         "no_speed",
         "no_memory",
         "no_env_print",
         "no_multi_process",
     ]






     def __init__(	self       ,  **a__						):
       for deprecated_arg in self.deprecated_args:
         if deprecated_arg in kwargs:
           _lowerCAmelCase		: Union[str, Any]						    =  deprecated_arg[3:]
           _lowerCAmelCase		: Optional[Any]						    =  not kwargs.pop(a__						)
           logger.warning(
               F"{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"
               F" {positive_arg}={kwargs[positive_arg]}"						)
       _lowerCAmelCase		: Dict						    =  kwargs.pop("""tpu_name"""       ,  self.tpu_name						)
       _lowerCAmelCase		: Optional[Any]						    =  kwargs.pop("""device_idx"""       ,  self.device_idx						)
       _lowerCAmelCase		: int						    =  kwargs.pop("""eager_mode"""       ,  self.eager_mode						)
       _lowerCAmelCase		: List[str]						    =  kwargs.pop("""use_xla"""       ,  self.use_xla						)
       super().__init__(**a__						)

     _UpperCamelCase							:    str	      =	field(
         default=SCREAMING_SNAKE_CASE_					,			metadata={"help": "Name of TPU"}					,			)
     _UpperCamelCase							:    int	      =	field(
         default=0					,			metadata={"help": "CPU / GPU device index. Defaults to 0."}					,			)
     _UpperCamelCase							:    bool	      =	field(default=SCREAMING_SNAKE_CASE_					,			metadata={"help": "Benchmark models in eager model."}	)
     _UpperCamelCase							:    bool	      =	field(
         default=SCREAMING_SNAKE_CASE_					,			metadata={
             "help": "Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."
         }					,			)






     @cached_property
     def 					__A						(	self						):
       requires_backends(self       ,  ["""tf"""]						)
       _lowerCAmelCase		: int						    =  None
       if self.tpu:
         try:
           if self.tpu_name:
             _lowerCAmelCase		: int						    =  tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name						)
           else:
             _lowerCAmelCase		: int						    =  tf.distribute.cluster_resolver.TPUClusterResolver()
         except ValueError:
           _lowerCAmelCase		: List[Any]						    =  None
       return tpu






     @cached_property
     def 					__A						(	self						):
       requires_backends(self       ,  ["""tf"""]						)
       if self.is_tpu:
         tf.config.experimental_connect_to_cluster(self._setup_tpu						)
         tf.tpu.experimental.initialize_tpu_system(self._setup_tpu						)

         _lowerCAmelCase		: List[str]						    =  tf.distribute.TPUStrategy(self._setup_tpu						)
       else:
         # currently no multi gpu is allowed
         if self.is_gpu:
           # TODO: Currently only single GPU is supported
           tf.config.set_visible_devices(self.gpu_list[self.device_idx]       ,  """GPU"""						)
           _lowerCAmelCase		: Dict						    =  tf.distribute.OneDeviceStrategy(device=F"/gpu:{self.device_idx}"						)
         else:
           tf.config.set_visible_devices([]       ,  """GPU"""						)  # disable GPU
           _lowerCAmelCase		: str						    =  tf.distribute.OneDeviceStrategy(device=F"/cpu:{self.device_idx}"						)

       return strategy






     @property
     def 					__A						(	self						):
       requires_backends(self       ,  ["""tf"""]						)
       return self._setup_tpu is not None






     @property
     def 					__A						(	self						):
       requires_backends(self       ,  ["""tf"""]						)
       return self._setup_strategy






     @property
     def 					__A						(	self						):
       requires_backends(self       ,  ["""tf"""]						)
       return tf.config.list_physical_devices("""GPU"""						)






     @property
     def 					__A						(	self						):
       requires_backends(self       ,  ["""tf"""]						)
       if self.cuda:
         return len(self.gpu_list						)
       return 0






     @property
     def 					__A						(	self						):
       return self.n_gpu > 0





"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


_a   :	int 					=     {
    'configuration_altclip': [
        'ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'AltCLIPConfig',
        'AltCLIPTextConfig',
        'AltCLIPVisionConfig',
    ],
    'processing_altclip': ['AltCLIPProcessor'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _a   :	Dict 					=     [
         'ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
         'AltCLIPPreTrainedModel',
         'AltCLIPModel',
         'AltCLIPTextModel',
         'AltCLIPVisionModel',
     ]


if TYPE_CHECKING:
     from .configuration_altclip import (
         ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
         AltCLIPConfig,
         AltCLIPTextConfig,
         AltCLIPVisionConfig,
     )
     from .processing_altclip import AltCLIPProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_altclip import (
              ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
              AltCLIPModel,
              AltCLIPPreTrainedModel,
              AltCLIPTextModel,
              AltCLIPVisionModel,
          )


else:
     import sys

     _a   :	List[Any] 					=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




