

'''simple docstring'''






from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_torch_available, is_torch_tpu_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_torch_available():
 import torch

if is_torch_tpu_available(check_device=False):
 import torch_xla.core.xla_model as xm


lowerCAmelCase__   		=      logging.get_logger(__name__)






@dataclass
class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE       :    Union[str, Any]							     =     [
      'no_inference',
      'no_cuda',
      'no_tpu',
      'no_speed',
      'no_memory',
      'no_env_print',
      'no_multi_process',
  ]






  def __init__( self  :	int   ,**lowercase__  :	Optional[Any]     ):
   for deprecated_arg in self.deprecated_args:
    if deprecated_arg in kwargs:
     __lowercase				    =					deprecated_arg[3:]
     setattr(self   ,lowercase__   ,not kwargs.pop(lowercase__     )     )
     logger.warning(
         F"{deprecated_arg} is depreciated. Please use --no_{positive_arg} or"
         F" {positive_arg}={kwargs[positive_arg]}"     )

   __lowercase				    =					kwargs.pop('''torchscript'''   ,self.torchscript     )
   __lowercase				    =					kwargs.pop('''torch_xla_tpu_print_metrics'''   ,self.torch_xla_tpu_print_metrics     )
   __lowercase				    =					kwargs.pop('''fp16_opt_level'''   ,self.fpaa_opt_level     )
   super().__init__(**lowercase__     )

  SCREAMING_SNAKE_CASE       :    bool							     =     field(default=lowerCamelCase__							,			metadata={'help': 'Trace the models using torchscript'} )
  SCREAMING_SNAKE_CASE       :    bool							     =     field(default=lowerCamelCase__							,			metadata={'help': 'Print Xla/PyTorch tpu metrics'} )
  SCREAMING_SNAKE_CASE       :    str							     =     field(
      default='O1'							,			metadata={
          'help': (
              'For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']. '
              'See details at https://nvidia.github.io/apex/amp.html'
          )
      }							,			)






  @cached_property
  def    SCREAMING_SNAKE_CASE ( self  :	Optional[Any]     ):
   requires_backends(self   ,['''torch''']     )
   logger.info('''PyTorch: setting up devices'''     )
   if not self.cuda:
    __lowercase				    =					torch.device('''cpu'''     )
    __lowercase				    =					0
   elif is_torch_tpu_available():
    __lowercase				    =					xm.xla_device()
    __lowercase				    =					0
   else:
    __lowercase				    =					torch.device('''cuda''' if torch.cuda.is_available() else '''cpu'''     )
    __lowercase				    =					torch.cuda.device_count()
   return device, n_gpu






  @property
  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   return is_torch_tpu_available() and self.tpu






  @property
  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]     ):
   requires_backends(self   ,['''torch''']     )
   # TODO(PVP): currently only single GPU is supported
   return torch.cuda.current_device()






  @property
  def    SCREAMING_SNAKE_CASE ( self  :	str     ):
   requires_backends(self   ,['''torch''']     )
   return self._setup_devices[0]






  @property
  def    SCREAMING_SNAKE_CASE ( self  :	Union[str, Any]     ):
   requires_backends(self   ,['''torch''']     )
   return self._setup_devices[1]






  @property
  def    SCREAMING_SNAKE_CASE ( self  :	Dict     ):
   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__)


