


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

from tqdm import auto as tqdm_lib


snake_case_						:			str													=							{
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

snake_case_						:			Dict													=							logging.WARNING







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE			  =os.getenv('''DATASETS_VERBOSITY'''	,a__)
				if env_level_str:
								if env_level_str in log_levels:
												return log_levels[env_level_str]
								else:
												logging.getLogger().warning(
												    f"Unknown option DATASETS_VERBOSITY={env_level_str}, "
												    f"has to be one of: { ', '.join(log_levels.keys()) }")
				return _default_log_level







def 						lowerCamelCase(   ):
				return __name__.split('''.''')[0]







def 						lowerCamelCase(   ):
				return logging.getLogger(_get_library_name())







def 						lowerCamelCase(   ):
				# Apply our default configuration to the library root logger.
				_SCREAMING_SNAKE_CASE			  =_get_library_root_logger()
				library_root_logger.setLevel(_get_default_logging_level())







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE			  =_get_library_root_logger()
				library_root_logger.setLevel(logging.NOTSET)







def 						lowerCamelCase(   a__ = None):
				if name is None:
								_SCREAMING_SNAKE_CASE			  =_get_library_name()
				return logging.getLogger(a__)







def 						lowerCamelCase(   ):
				return _get_library_root_logger().getEffectiveLevel()







def 						lowerCamelCase(   a__):
				_get_library_root_logger().setLevel(a__)







def 						lowerCamelCase(   ):
				return set_verbosity(a__)







def 						lowerCamelCase(   ):
				return set_verbosity(a__)







def 						lowerCamelCase(   ):
				return set_verbosity(a__)







def 						lowerCamelCase(   ):
				return set_verbosity(a__)







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE			  =False







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE			  =True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()

class 						A__							:




						def __init__(       self					:      Optional[Any]				,    *_a					:      Tuple				,    **_a					:      Dict  )							->     Tuple:  # pylint: disable=unused-argument


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =args[0] if args else None




						def __iter__(       self					:      Dict  )							->     Optional[Any]:


										"""simple docstring"""





										return iter(self._iterator  )




						def __getattr__(       self					:      Tuple				,    _a					:      Tuple  )							->     Any:


										"""simple docstring"""





										def empty_fn(*_a					:      Union[str, Any]				,    **_a					:      int  ):  # pylint: disable=unused-argument
														return

										return empty_fn




						def __enter__(       self					:      int  )							->     int:


										"""simple docstring"""





										return self




						def __exit__(       self					:      List[str]				,    _a					:      Optional[int]				,    _a					:      Tuple				,    _a					:      Union[str, Any]  )							->     Optional[Any]:


										"""simple docstring"""





										return
snake_case_						:			Optional[Any]													=							True

class 						A__							:




						def __call__(       self					:      Optional[int]				,    *_a					:      Union[str, Any]				,    _a					:      Dict=False				,    **_a					:      int  )							->     Union[str, Any]:


										"""simple docstring"""





										if _tqdm_active and not disable:
														return tqdm_lib.tqdm(*_a				,    **_a  )
										else:
														return EmptyTqdm(*_a				,    **_a  )




						def 							__UpperCamelCase				(       self					:      Tuple				,    *_a					:      Any				,    **_a					:      int  )							->     int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =None
										if _tqdm_active:
														return tqdm_lib.tqdm.set_lock(*_a				,    **_a  )




						def 							__UpperCamelCase				(       self					:      int  )							->     List[Any]:


										"""simple docstring"""





										if _tqdm_active:
														return tqdm_lib.tqdm.get_lock()
snake_case_						:			Dict													=							_tqdm_cls()







def 						lowerCamelCase(   ):
				global _tqdm_active
				return bool(_tqdm_active)







def 						lowerCamelCase(   ):
				global _tqdm_active
				_SCREAMING_SNAKE_CASE			  =True







def 						lowerCamelCase(   ):
				global _tqdm_active
				_SCREAMING_SNAKE_CASE			  =False



from ...utils import logging
from ..ta.modeling_tf_ta import TFTaEncoderModel, TFTaForConditionalGeneration, TFTaModel
from .configuration_mta import MTaConfig


snake_case_						:			List[Any]													=							logging.get_logger(__name__)

snake_case_						:			Optional[Any]													=							'''T5Config'''

class 						A__							(		UpperCamelCase__  ):
						UpperCAmelCase             =						"mt5"
						UpperCAmelCase             =						MTaConfig

class 						A__							(		UpperCamelCase__  ):
						UpperCAmelCase             =						"mt5"
						UpperCAmelCase             =						MTaConfig

class 						A__							(		UpperCamelCase__  ):
						UpperCAmelCase             =						"mt5"
						UpperCAmelCase             =						MTaConfig