

"""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


__A		  =     logging.get_logger(__name__)





@dataclass
class        snake_case      (							lowercase__    ):
				SCREAMING_SNAKE_CASE_  : Any   =    [
				    """no_inference""",
				    """no_cuda""",
				    """no_tpu""",
				    """no_speed""",
				    """no_memory""",
				    """no_env_print""",
				    """no_multi_process""",
				]

				def __init__(      self				:							Tuple	,    **UpperCamelCase__				:							int)->  Any:



						'''simple docstring'''


						for deprecated_arg in self.deprecated_args:
								if deprecated_arg in kwargs:
										__lowerCAmelCase:			Optional[int]        =     deprecated_arg[3:]
										setattr(self	,    UpperCAmelCase__	,    not kwargs.pop(UpperCAmelCase__))
										logger.warning(
										    f"{deprecated_arg} is depreciated. Please use --no_{positive_arg} or"
										    f" {positive_arg}={kwargs[positive_arg]}")

						__lowerCAmelCase:			int        =     kwargs.pop("torchscript"	,    self.torchscript)
						__lowerCAmelCase:			List[str]        =     kwargs.pop("torch_xla_tpu_print_metrics"	,    self.torch_xla_tpu_print_metrics)
						__lowerCAmelCase:			int        =     kwargs.pop("fp16_opt_level"	,    self.fpaa_opt_level)
						super().__init__(**UpperCAmelCase__)

				SCREAMING_SNAKE_CASE_  : List[str]   =    field(default=lowercase__,				metadata={"""help""": """Trace the models using torchscript"""}    )
				SCREAMING_SNAKE_CASE_  : str   =    field(default=lowercase__,				metadata={"""help""": """Print Xla/PyTorch tpu metrics"""}    )
				SCREAMING_SNAKE_CASE_  : Any   =    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 				lowercase_	(      self				:							List[Any])->  int:



						'''simple docstring'''


						requires_backends(self	,    ["torch"])
						logger.info("PyTorch: setting up devices")
						if not self.cuda:
								__lowerCAmelCase:			List[Any]        =     torch.device("cpu")
								__lowerCAmelCase:			int        =     0
						elif is_torch_tpu_available():
								__lowerCAmelCase:			Optional[Any]        =     xm.xla_device()
								__lowerCAmelCase:			int        =     0
						else:
								__lowerCAmelCase:			Optional[Any]        =     torch.device("cuda" if torch.cuda.is_available() else "cpu")
								__lowerCAmelCase:			str        =     torch.cuda.device_count()
						return device, n_gpu

				@property
				def 				lowercase_	(      self				:							Tuple)->  Any:



						'''simple docstring'''


						return is_torch_tpu_available() and self.tpu

				@property
				def 				lowercase_	(      self				:							int)->  Union[str, Any]:



						'''simple docstring'''


						requires_backends(self	,    ["torch"])
						# TODO(PVP): currently only single GPU is supported
						return torch.cuda.current_device()

				@property
				def 				lowercase_	(      self				:							int)->  Union[str, Any]:



						'''simple docstring'''


						requires_backends(self	,    ["torch"])
						return self._setup_devices[0]

				@property
				def 				lowercase_	(      self				:							Union[str, Any])->  List[str]:



						'''simple docstring'''


						requires_backends(self	,    ["torch"])
						return self._setup_devices[1]




				@property
				def 				lowercase_	(      self				:							Any)->  Dict:



						'''simple docstring'''


						return self.n_gpu > 0





'''simple docstring'''





# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
UpperCamelCase_    						=       abspath(join(dirname(__file__), """src"""))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="""ignore""", category=FutureWarning)






def 				_lowerCAmelCase			(   __magic_name__						:     int						)				->  Tuple:
						config.addinivalue_line(
						    '''markers'''   , '''is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'''						)
						config.addinivalue_line(
						    '''markers'''   , '''is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'''						)
						config.addinivalue_line('''markers'''   , '''is_pipeline_test: mark test to run only when pipelines are tested'''						)
						config.addinivalue_line('''markers'''   , '''is_staging_test: mark test to run only in the staging environment'''						)
						config.addinivalue_line('''markers'''   , '''accelerate_tests: mark test that require accelerate'''						)
						config.addinivalue_line('''markers'''   , '''tool_tests: mark the tool tests that are run on their specific schedule'''						)






def 				_lowerCAmelCase			(   __magic_name__						:     int						)				->  Any:
						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(__magic_name__						)






def 				_lowerCAmelCase			(   __magic_name__						:     Any						)				->  Any:
						from transformers.testing_utils import pytest_terminal_summary_main

						lowercase :							Optional[Any]    		=terminalreporter.config.getoption('''--make-reports'''						)
						if make_reports:
												pytest_terminal_summary_main(__magic_name__   , id=__magic_name__						)






def 				_lowerCAmelCase			(   __magic_name__						:     Tuple   , __magic_name__						:     Union[str, Any]						)				->  List[str]:
						# If no tests are collected, pytest exists with code 5, which makes the CI fail.
						if exitstatus == 5:
												lowercase :							Optional[int]    		=0


# Doctest custom flag to ignore output.
UpperCamelCase_    						=       doctest.register_optionflag("""IGNORE_RESULT""")

UpperCamelCase_    						=       doctest.OutputChecker





class 		__SCREAMING_SNAKE_CASE							(			lowercase__      ):







				def  lowerCamelCase_	(       self     :		Optional[Any]		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		List[Any]   ):
										'''simple docstring'''
										if IGNORE_RESULT & optionflags:
																return True
										return OutputChecker.check_output(self		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__   )



UpperCamelCase_    						=       CustomOutputChecker
UpperCamelCase_    						=       HfDoctestModule







UpperCamelCase_    						=       HfDocTestParser





