
'''simple docstring'''


import functools
import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


__lowercase							:   Dict					=     threading.Lock()
__lowercase							:   Optional[logging.Handler]					=     None

__lowercase							:   List[str]					=     {
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

__lowercase							:   List[str]					=     logging.WARNING

__lowercase							:   List[str]					=     True




def lowercase_	(   )     ->							List[str]:
					'''simple docstring'''

					lowerCamelCase_					:      int     =		os.getenv('''TRANSFORMERS_VERBOSITY'''			,       _lowercase				)
					if env_level_str:
										if env_level_str in log_levels:
															return log_levels[env_level_str]
										else:
															logging.getLogger().warning(
															    F"""Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, """
															    F"""has to be one of: { ", ".join(log_levels.keys()				) }"""				)
					return _default_log_level




def lowercase_	(   )     ->							str:
					'''simple docstring'''

					return __name__.split('''.'''				)[0]




def lowercase_	(   )     ->							logging.Logger:
					'''simple docstring'''

					return logging.getLogger(_get_library_name()				)




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					global _default_handler

					with _lock:
										if _default_handler:
															# This library has already configured the library root logger.
															return
										lowerCamelCase_					:      Any     =		logging.StreamHandler()  # Set sys.stderr as stream.
										lowerCamelCase_					:      Tuple     =		sys.stderr.flush

										# Apply our default configuration to the library root logger.
										lowerCamelCase_					:      str     =		_get_library_root_logger()
										library_root_logger.addHandler(_default_handler				)
										library_root_logger.setLevel(_get_default_logging_level()				)
										lowerCamelCase_					:      List[str]     =		False




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					global _default_handler

					with _lock:
										if not _default_handler:
															return

										lowerCamelCase_					:      Dict     =		_get_library_root_logger()
										library_root_logger.removeHandler(_default_handler				)
										library_root_logger.setLevel(logging.NOTSET				)
										lowerCamelCase_					:      str     =		None




def lowercase_	(   )     ->							Union[str, Any]:
					'''simple docstring'''

					return log_levels




def lowercase_	(   _lowercase = None				)     ->							logging.Logger:
					'''simple docstring'''

					if name is None:
										lowerCamelCase_					:      Optional[int]     =		_get_library_name()

					_configure_library_root_logger()
					return logging.getLogger(_lowercase				)




def lowercase_	(   )     ->							int:
					'''simple docstring'''

					_configure_library_root_logger()
					return _get_library_root_logger().getEffectiveLevel()




def lowercase_	(   _lowercase				)     ->							None:
					'''simple docstring'''

					_configure_library_root_logger()
					_get_library_root_logger().setLevel(_lowercase				)




def lowercase_	(   )     ->							List[Any]:
					'''simple docstring'''

					return set_verbosity(_lowercase				)




def lowercase_	(   )     ->							Union[str, Any]:
					'''simple docstring'''

					return set_verbosity(_lowercase				)




def lowercase_	(   )     ->							int:
					'''simple docstring'''

					return set_verbosity(_lowercase				)




def lowercase_	(   )     ->							Optional[Any]:
					'''simple docstring'''

					return set_verbosity(_lowercase				)




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					_configure_library_root_logger()

					assert _default_handler is not None
					_get_library_root_logger().removeHandler(_default_handler				)




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					_configure_library_root_logger()

					assert _default_handler is not None
					_get_library_root_logger().addHandler(_default_handler				)




def lowercase_	(   _lowercase				)     ->							None:
					'''simple docstring'''

					_configure_library_root_logger()

					assert handler is not None
					_get_library_root_logger().addHandler(_lowercase				)




def lowercase_	(   _lowercase				)     ->							None:
					'''simple docstring'''

					_configure_library_root_logger()

					assert handler is not None and handler not in _get_library_root_logger().handlers
					_get_library_root_logger().removeHandler(_lowercase				)




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					_configure_library_root_logger()
					lowerCamelCase_					:      List[Any]     =		False




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					_configure_library_root_logger()
					lowerCamelCase_					:      List[Any]     =		True




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					lowerCamelCase_					:      List[Any]     =		_get_library_root_logger().handlers

					for handler in handlers:
										lowerCamelCase_					:      str     =		logging.Formatter('''[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'''				)
										handler.setFormatter(_lowercase				)




def lowercase_	(   )     ->							None:
					'''simple docstring'''

					lowerCamelCase_					:      Any     =		_get_library_root_logger().handlers

					for handler in handlers:
										handler.setFormatter(_lowercase				)




def lowercase_	(   self			,       *_lowercase			,       **_lowercase				)     ->							Optional[int]:
					'''simple docstring'''

					lowerCamelCase_					:      Tuple     =		os.getenv('''TRANSFORMERS_NO_ADVISORY_WARNINGS'''			,       _lowercase				)
					if no_advisory_warnings:
										return
					self.warning(*_lowercase			,       **_lowercase				)


__lowercase							:   int					=     warning_advice




@functools.lru_cache(_lowercase				)
def lowercase_	(   self			,       *_lowercase			,       **_lowercase				)     ->							str:
					'''simple docstring'''

					self.warning(*_lowercase			,       **_lowercase				)


__lowercase							:   str					=     warning_once

class 	__lowercase				:

			def __init__(self			,   *A			,   **A      ):  # pylint: disable=unused-argument
								lowerCamelCase_					:      Union[str, Any]     =		args[0] if args else None

			def __iter__(self      ):
								return iter(self._iterator      )

			def __getattr__(self			,   A      ):

								def empty_fn(*A			,   **A      ):  # pylint: disable=unused-argument
													return

								return empty_fn

			def __enter__(self      ):
								return self






			def __exit__(self			,   A			,   A			,   A      ):
								return

class 	__lowercase				:

			def __call__(self			,   *A			,   **A      ):
								if _tqdm_active:
													return tqdm_lib.tqdm(*A			,   **A      )
								else:
													return EmptyTqdm(*A			,   **A      )

			def        UpperCAmelCase__ (self			,   *A			,   **A      ):
								lowerCamelCase_					:      List[Any]     =		None
								if _tqdm_active:
													return tqdm_lib.tqdm.set_lock(*A			,   **A      )






			def        UpperCAmelCase__ (self      ):
								if _tqdm_active:
													return tqdm_lib.tqdm.get_lock()
__lowercase							:   List[Any]					=     _tqdm_cls()




def lowercase_	(   )     ->							bool:
					'''simple docstring'''

					global _tqdm_active
					return bool(_tqdm_active				)




def lowercase_	(   )     ->							str:
					'''simple docstring'''

					global _tqdm_active
					lowerCamelCase_					:      List[Any]     =		True
					hf_hub_utils.enable_progress_bars()






def lowercase_	(   )     ->							Dict:
					'''simple docstring'''

					global _tqdm_active
					lowerCamelCase_					:      List[Any]     =		False
					hf_hub_utils.disable_progress_bars()




'''simple docstring'''


import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


__lowercase							:   Union[str, Any]					=     logging.get_logger(__name__)




def lowercase_	(   )     ->							Union[str, Any]:
					'''simple docstring'''

					lowerCamelCase_					:      Optional[Any]     =		os.getenv('''SM_HP_MP_PARAMETERS'''			,       '''{}'''				)
					try:
										# Parse it and check the field "partitions" is included, it is required for model parallel.
										lowerCamelCase_					:      Optional[Any]     =		json.loads(_lowercase				)
										if "partitions" not in smp_options:
															return False
					except json.JSONDecodeError:
										return False

					# Get the sagemaker specific framework parameters from mpi_options variable.
					lowerCamelCase_					:      List[str]     =		os.getenv('''SM_FRAMEWORK_PARAMS'''			,       '''{}'''				)
					try:
										# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
										lowerCamelCase_					:      List[str]     =		json.loads(_lowercase				)
										if not mpi_options.get('''sagemaker_mpi_enabled'''			,       _lowercase				):
															return False
					except json.JSONDecodeError:
										return False
					# Lastly, check if the `smdistributed` module is present.
					return importlib.util.find_spec('''smdistributed'''				) is not None


if is_sagemaker_model_parallel_available():
					import smdistributed.modelparallel.torch as smp

					smp.init()






@dataclass
class 	__lowercase				(  _lowercase    ):
			lowerCamelCase			:		str	      =			field(
			    default=""      ,     metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}      ,     )

			def        UpperCAmelCase__ (self      ):
								super().__post_init__()
								warnings.warn(
								    '''`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '''
								    '''`TrainingArguments` instead.'''			,   A			,   )

			@cached_property
			def        UpperCAmelCase__ (self      ):
								logger.info('''PyTorch: setting up devices'''      )
								if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
													logger.warning(
													    '''torch.distributed process group is initialized, but local_rank == -1. '''
													    '''In order to use Torch DDP, launch your script with `python -m torch.distributed.launch'''      )
								if self.no_cuda:
													lowerCamelCase_					:      Optional[int]     =		torch.device('''cpu'''      )
													lowerCamelCase_					:      Dict     =		0
								elif is_sagemaker_model_parallel_available():
													lowerCamelCase_					:      int     =		smp.local_rank()
													lowerCamelCase_					:      str     =		torch.device('''cuda'''			,   A      )
													lowerCamelCase_					:      Tuple     =		1
								elif is_sagemaker_dp_enabled():
													import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

													torch.distributed.init_process_group(backend='''smddp'''			,   timeout=self.ddp_timeout_delta      )
													lowerCamelCase_					:      List[Any]     =		int(os.getenv('''SMDATAPARALLEL_LOCAL_RANK'''      )      )
													lowerCamelCase_					:      Union[str, Any]     =		torch.device('''cuda'''			,   self.local_rank      )
													lowerCamelCase_					:      List[str]     =		1
								elif self.local_rank == -1:
													# if n_gpu is > 1 we'll use nn.DataParallel.
													# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
													# Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
													# trigger an error that a device index is missing. Index 0 takes into account the
													# GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
													# will use the first GPU in that env, i.e. GPU#1
													lowerCamelCase_					:      List[str]     =		torch.device('''cuda:0''' if torch.cuda.is_available() else '''cpu'''      )
													# Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
													# the default value.
													lowerCamelCase_					:      Any     =		torch.cuda.device_count()
								else:
													# Here, we'll use torch.distributed.
													# Initializes the distributed backend which will take care of synchronizing nodes/GPUs
													if not torch.distributed.is_initialized():
																		torch.distributed.init_process_group(backend='''nccl'''			,   timeout=self.ddp_timeout_delta      )
													lowerCamelCase_					:      Any     =		torch.device('''cuda'''			,   self.local_rank      )
													lowerCamelCase_					:      List[str]     =		1

								if device.type == "cuda":
													torch.cuda.set_device(A      )

								return device

			@property
			def        UpperCAmelCase__ (self      ):
								if is_sagemaker_model_parallel_available():
													return smp.dp_size()

								return super().world_size

			@property
			def        UpperCAmelCase__ (self      ):
								return not is_sagemaker_model_parallel_available()






			@property
			def        UpperCAmelCase__ (self      ):
								return False


