
"""simple docstring"""






import contextlib
from multiprocessing import Pool, RLock

from tqdm.auto import tqdm

from ..utils import experimental, logging


UpperCAmelCase        =				logging.get_logger(__name__)



class 			lowercase					:
			lowercase        =     None





@experimental
def __magic_name__	(				_lowerCamelCase:		Tuple,					_lowerCamelCase:		Any,					_lowerCamelCase:		Tuple,					_lowerCamelCase:		Dict,					_lowerCamelCase:		List[Any],					_lowerCamelCase:		Optional[int],					_lowerCamelCase:		Optional[Any]			)					->						str:

	'''simple docstring'''




	if ParallelBackendConfig.backend_name is None:
		return _map_with_multiprocessing_pool(
		    _lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase			)

	return _map_with_joblib(_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase,					_lowerCamelCase			)




def __magic_name__	(				_lowerCamelCase:		Dict,					_lowerCamelCase:		int,					_lowerCamelCase:		Optional[Any],					_lowerCamelCase:		Tuple,					_lowerCamelCase:		Dict,					_lowerCamelCase:		Tuple,					_lowerCamelCase:		Tuple			)					->						Dict:

	'''simple docstring'''




	lowerCAmelCase												=  num_proc if num_proc <= len(_lowerCamelCase			) else len(_lowerCamelCase			)
	lowerCAmelCase												=  []  # We organize the splits ourselve (contiguous splits)
	for index in range(_lowerCamelCase			):
		lowerCAmelCase												=  len(_lowerCamelCase			) // num_proc
		lowerCAmelCase												=  len(_lowerCamelCase			) % num_proc
		lowerCAmelCase												=  div * index + min(_lowerCamelCase,					_lowerCamelCase			)
		lowerCAmelCase												=  start + div + (1 if index < mod else 0)
		split_kwds.append((function, iterable[start:end], types, index, disable_tqdm, desc)			)

	if len(_lowerCamelCase			) != sum(len(i[1]			) for i in split_kwds			):
		raise ValueError(
		    F"""Error dividing inputs iterable among processes. """
		    F"""Total number of objects {len(_lowerCamelCase			)}, """
		    F"""length: {sum(len(i[1]			) for i in split_kwds			)}"""			)

	logger.info(
	    F"""Spawning {num_proc} processes for {len(_lowerCamelCase			)} objects in slices of {[len(i[1]			) for i in split_kwds]}"""			)
	lowerCAmelCase							,       lowerCAmelCase												=  None, None
	if not disable_tqdm:
		lowerCAmelCase							,       lowerCAmelCase												=  (RLock(),), tqdm.set_lock
	with Pool(_lowerCamelCase,					initargs=_lowerCamelCase,					initializer=_lowerCamelCase			) as pool:
		lowerCAmelCase												=  pool.map(_lowerCamelCase,					_lowerCamelCase			)
	logger.info(F"""Finished {num_proc} processes"""			)
	lowerCAmelCase												=  [obj for proc_res in mapped for obj in proc_res]
	logger.info(F"""Unpacked {len(_lowerCamelCase			)} objects"""			)

	return mapped




def __magic_name__	(				_lowerCamelCase:		List[Any],					_lowerCamelCase:		Any,					_lowerCamelCase:		Tuple,					_lowerCamelCase:		int,					_lowerCamelCase:		Optional[int],					_lowerCamelCase:		List[Any],					_lowerCamelCase:		Any			)					->						int:

	'''simple docstring'''




	import joblib

	with joblib.parallel_backend(ParallelBackendConfig.backend_name,					n_jobs=_lowerCamelCase			):
		return joblib.Parallel()(
		    joblib.delayed(_lowerCamelCase			)((function, obj, types, None, True, None)			) for obj in iterable			)




@experimental
@contextlib.contextmanager
def __magic_name__	(				_lowerCamelCase:		str			)					->						Any:

	'''simple docstring'''




	lowerCAmelCase												=  backend_name

	if backend_name == "spark":
		from joblibspark import register_spark

		register_spark()

		# TODO: call create_cache_and_write_probe if "download" in steps
		# TODO: raise NotImplementedError when Dataset.map etc is called

	try:
		yield
	finally:
		lowerCAmelCase												=  None




"""simple docstring"""






import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar



class 			lowercase					( unittest.TestCase		):






			def 					UpperCAmelCase							(self  :	Union[str, Any]			)       ->	Optional[Any]:





				"""simple docstring"""


				lowerCAmelCase												=  logging.get_logger()

				# the current default level is logging.WARNING
				lowerCAmelCase												=  logging.get_verbosity()

				logging.set_verbosity_error()
				self.assertEqual(logger.getEffectiveLevel()      ,logging.get_verbosity()			)

				logging.set_verbosity_warning()
				self.assertEqual(logger.getEffectiveLevel()      ,logging.get_verbosity()			)

				logging.set_verbosity_info()
				self.assertEqual(logger.getEffectiveLevel()      ,logging.get_verbosity()			)

				logging.set_verbosity_debug()
				self.assertEqual(logger.getEffectiveLevel()      ,logging.get_verbosity()			)

				# restore to the original level
				logging.set_verbosity(SCREAMING_SNAKE_CASE_			)






			def 					UpperCAmelCase							(self  :	Union[str, Any]			)       ->	Optional[int]:





				"""simple docstring"""


				lowerCAmelCase												=  logging.get_verbosity()

				lowerCAmelCase												=  logging.get_logger('''transformers.models.bart.tokenization_bart'''			)
				lowerCAmelCase												=  '''Testing 1, 2, 3'''

				# should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
				if level_origin <= logging.WARNING:
					with CaptureLogger(SCREAMING_SNAKE_CASE_			) as cl:
						logger.warning(SCREAMING_SNAKE_CASE_			)
					self.assertEqual(cl.out      ,msg + '''\n'''			)

				# this is setting the level for all of `transformers.*` loggers
				logging.set_verbosity_error()

				# should not be able to log warnings
				with CaptureLogger(SCREAMING_SNAKE_CASE_			) as cl:
					logger.warning(SCREAMING_SNAKE_CASE_			)
				self.assertEqual(cl.out      ,''''''			)

				# should be able to log warnings again
				logging.set_verbosity_warning()
				with CaptureLogger(SCREAMING_SNAKE_CASE_			) as cl:
					logger.warning(SCREAMING_SNAKE_CASE_			)
				self.assertEqual(cl.out      ,msg + '''\n'''			)

				# restore to the original level
				logging.set_verbosity(SCREAMING_SNAKE_CASE_			)






			@mockenv(TRANSFORMERS_VERBOSITY='''error'''			)
			def 					UpperCAmelCase							(self  :	Any			)       ->	str:





				"""simple docstring"""


				transformers.utils.logging._reset_library_root_logger()
				# this action activates the env var
				lowerCAmelCase												=  logging.get_logger('''transformers.models.bart.tokenization_bart'''			)

				lowerCAmelCase												=  os.getenv('''TRANSFORMERS_VERBOSITY'''      ,SCREAMING_SNAKE_CASE_			)
				lowerCAmelCase												=  logging.log_levels[env_level_str]

				lowerCAmelCase												=  logging.get_verbosity()
				self.assertEqual(
				    SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_      ,F"""TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}"""      ,)

				# restore to the original level
				lowerCAmelCase												=  ''''''
				transformers.utils.logging._reset_library_root_logger()






			@mockenv(TRANSFORMERS_VERBOSITY='''super-error'''			)
			def 					UpperCAmelCase							(self  :	List[Any]			)       ->	Tuple:





				"""simple docstring"""


				transformers.utils.logging._reset_library_root_logger()
				lowerCAmelCase												=  logging.logging.getLogger()
				with CaptureLogger(SCREAMING_SNAKE_CASE_			) as cl:
					# this action activates the env var
					logging.get_logger('''transformers.models.bart.tokenization_bart'''			)
				self.assertIn('''Unknown option TRANSFORMERS_VERBOSITY=super-error'''      ,cl.out			)

				# no need to restore as nothing was changed






			def 					UpperCAmelCase							(self  :	Dict			)       ->	Any:





				"""simple docstring"""


				transformers.utils.logging._reset_library_root_logger()

				lowerCAmelCase												=  logging.get_logger('''transformers.models.bart.tokenization_bart'''			)
				lowerCAmelCase												=  '''Testing 1, 2, 3'''

				with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='''1'''			):
					# nothing should be logged as env var disables this method
					with CaptureLogger(SCREAMING_SNAKE_CASE_			) as cl:
						logger.warning_advice(SCREAMING_SNAKE_CASE_			)
					self.assertEqual(cl.out      ,''''''			)

				with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=''''''			):
					# should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
					with CaptureLogger(SCREAMING_SNAKE_CASE_			) as cl:
						logger.warning_advice(SCREAMING_SNAKE_CASE_			)
					self.assertEqual(cl.out      ,msg + '''\n'''			)





def __magic_name__	(				)					->						List[Any]:

	'''simple docstring'''




	disable_progress_bar()
	assert are_progress_bars_disabled()

	enable_progress_bar()
	assert not are_progress_bars_disabled()


