
"""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     :			Any  						=			logging.get_logger(__name__)

@dataclass
class 						a__		( a_		):
   __lowerCAmelCase				=							[
       """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:
                        lowercase       :							Optional[Any]									=				deprecated_arg[3:]
                        lowercase       :							List[str]									=				not kwargs.pop(_a							)
                        logger.warning(
                            f"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
                            f""" {positive_arg}={kwargs[positive_arg]}"""							)
          lowercase       :							int									=				kwargs.pop("tpu_name"      ,       self.tpu_name							)
          lowercase       :							Any									=				kwargs.pop("device_idx"      ,       self.device_idx							)
          lowercase       :							int									=				kwargs.pop("eager_mode"      ,       self.eager_mode							)
          lowercase       :							Optional[Any]									=				kwargs.pop("use_xla"      ,       self.use_xla							)
          super().__init__(**_a							)

   __lowerCAmelCase				=							field(
       default=a_,     metadata={"""help""": """Name of TPU"""},     )
   __lowerCAmelCase				=							field(
       default=0,     metadata={"""help""": """CPU / GPU device index. Defaults to 0."""},     )
   __lowerCAmelCase				=							field(default=a_,     metadata={"""help""": """Benchmark models in eager model."""}		)
   __lowerCAmelCase				=							field(
       default=a_,     metadata={
           """help""": """Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."""
       },     )
   @cached_property
   def      __magic_name__     (     self							):
          requires_backends(self      ,       ["tf"]							)
          lowercase       :							List[str]									=				None
          if self.tpu:
                 try:
                        if self.tpu_name:
                               lowercase       :							str									=				tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name							)
                        else:
                               lowercase       :							Optional[Any]									=				tf.distribute.cluster_resolver.TPUClusterResolver()
                 except ValueError:
                        lowercase       :							Optional[Any]									=				None
          return tpu
   @cached_property
   def      __magic_name__     (     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							)

                 lowercase       :							Dict									=				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"							)
                        lowercase       :							Any									=				tf.distribute.OneDeviceStrategy(device=f"""/gpu:{self.device_idx}"""							)
                 else:
                        tf.config.set_visible_devices([]      ,       "GPU"							)  # disable GPU
                        lowercase       :							Any									=				tf.distribute.OneDeviceStrategy(device=f"""/cpu:{self.device_idx}"""							)

          return strategy
   @property
   def      __magic_name__     (     self							):
          requires_backends(self      ,       ["tf"]							)
          return self._setup_tpu is not None
   @property
   def      __magic_name__     (     self							):
          requires_backends(self      ,       ["tf"]							)
          return self._setup_strategy
   @property
   def      __magic_name__     (     self							):
          requires_backends(self      ,       ["tf"]							)
          return tf.config.list_physical_devices("GPU"							)
   @property
   def      __magic_name__     (     self							):
          requires_backends(self      ,       ["tf"]							)
          if self.cuda:
                 return len(self.gpu_list							)
          return 0

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




"""simple docstring"""




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A     :			Optional[int]  						=			{
    """configuration_mgp_str""": ["""MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MgpstrConfig"""],
    """processing_mgp_str""": ["""MgpstrProcessor"""],
    """tokenization_mgp_str""": ["""MgpstrTokenizer"""],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A     :			Any  						=			[
       """MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """MgpstrModel""",
       """MgpstrPreTrainedModel""",
       """MgpstrForSceneTextRecognition""",
   ]

if TYPE_CHECKING:
   from .configuration_mgp_str import MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP, MgpstrConfig
   from .processing_mgp_str import MgpstrProcessor
   from .tokenization_mgp_str import MgpstrTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_mgp_str import (
          MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST,
          MgpstrForSceneTextRecognition,
          MgpstrModel,
          MgpstrPreTrainedModel,
      )
else:
   import sys

   _A     :			Tuple  						=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


