





'''simple docstring'''
from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


a__							:							Optional[Any]			=			logging.get_logger(__name__)

a__							:							Optional[Any]			=			{
    '''mnaylor/mega-base-wikitext''': '''https://huggingface.co/mnaylor/mega-base-wikitext/resolve/main/config.json''',
}

class 					snake_case					(   _lowerCAmelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		="mega"






 def __init__(	self	:							int							,     __A	:							Dict=3_0_5_2_2							,     __A	:							List[str]=1_2_8							,     __A	:							int=4							,     __A	:							str=2_5_6							,     __A	:							List[Any]=1_6							,     __A	:							List[str]=True							,     __A	:							Any=6_4							,     __A	:							Optional[Any]=False							,     __A	:							Tuple=-1							,     __A	:							Any=None							,     __A	:							int=True							,     __A	:							Optional[Any]="scalenorm"							,     __A	:							Any=True							,     __A	:							Union[str, Any]="silu"							,     __A	:							Optional[Any]="softmax"							,     __A	:							Any=0.1							,     __A	:							Any=0.1							,     __A	:							Dict=0.1							,     __A	:							List[str]=False							,     __A	:							List[str]=True							,     __A	:							str=2_5_6							,     __A	:							Optional[Any]=True							,     __A	:							Optional[Any]=0.1							,     __A	:							int=2_0_4_8							,     __A	:							Any=False							,     __A	:							int=2							,     __A	:							Optional[int]=0.02							,     __A	:							str=0.2							,     __A	:							int=0.02							,     __A	:							Union[str, Any]=1.0							,     __A	:							Any=1							,     __A	:							List[Any]=0							,     __A	:							Optional[int]=2							,     __A	:							int="rotary"							,     __A	:							Any=None							,     __A	:							List[str]=True							,     __A	:							str=True							,     **__A	:							Optional[int]							,     ):
        super().__init__(pad_token_id=_lowerCamelCase							,     bos_token_id=_lowerCamelCase							,     eos_token_id=_lowerCamelCase							,     **_lowerCamelCase     )

        __UpperCamelCase	=  vocab_size
        __UpperCamelCase	=  hidden_size
        __UpperCamelCase	=  num_hidden_layers
        __UpperCamelCase	=  activation
        __UpperCamelCase	=  attention_activation
        __UpperCamelCase	=  intermediate_size
        __UpperCamelCase	=  ema_projection_size
        __UpperCamelCase	=  bidirectional
        __UpperCamelCase	=  shared_representation_size
        __UpperCamelCase	=  use_chunking
        __UpperCamelCase	=  chunk_size
        __UpperCamelCase	=  truncation
        __UpperCamelCase	=  normalize_before_mega
        __UpperCamelCase	=  normalization_type
        __UpperCamelCase	=  norm_affine
        __UpperCamelCase	=  dropout_prob
        __UpperCamelCase	=  hidden_dropout_prob
        __UpperCamelCase	=  attention_probs_dropout_prob
        __UpperCamelCase	=  use_feature_dropout
        __UpperCamelCase	=  use_normalized_ffn
        __UpperCamelCase	=  nffn_hidden_size
        __UpperCamelCase	=  normalize_before_ffn
        __UpperCamelCase	=  nffn_activation_dropout_prob
        __UpperCamelCase	=  max_positions
        __UpperCamelCase	=  add_token_type_embeddings
        __UpperCamelCase	=  type_vocab_size
        __UpperCamelCase	=  initializer_range
        __UpperCamelCase	=  ema_delta_alpha_range
        __UpperCamelCase	=  ema_beta_range
        __UpperCamelCase	=  ema_gamma_omega_range
        __UpperCamelCase	=  relative_positional_bias
        __UpperCamelCase	=  use_cache
        __UpperCamelCase	=  classifier_dropout
        __UpperCamelCase	=  add_lm_hidden_dense_layer
        __UpperCamelCase	=  1  # not used but required by Hugging Face






class 					snake_case					(   _lowerCAmelCase	):




 """simple docstring"""



 @property
 def 	_lowerCamelCase (	self	:							Union[str, Any]     ):
        if self.task == "multiple-choice":
               __UpperCamelCase	=  {0: 'batch', 1: 'choice', 2: 'sequence'}
        else:
               __UpperCamelCase	=  {0: 'batch', 1: 'sequence'}
        return OrderedDict(
            [
                ('input_ids', dynamic_axis),
                ('attention_mask', dynamic_axis),
            ]     )







'''simple docstring'''
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

from tqdm import auto as tqdm_lib


a__							:							Optional[int]			=threading.Lock()
a__							:							Optional[logging.Handler]			=None

a__							:							Optional[Any]			={
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

a__							:							List[Any]			=logging.WARNING

a__							:							str			=True
def     lowercase__       (       )			->				int:



       """simple docstring"""






       __UpperCamelCase	=  os.getenv('DIFFUSERS_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 DIFFUSERS_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
              __UpperCamelCase	=  logging.StreamHandler()  # Set sys.stderr as stream.
              __UpperCamelCase	=  sys.stderr.flush

              # Apply our default configuration to the library root logger.
              __UpperCamelCase	=  _get_library_root_logger()
              library_root_logger.addHandler(_default_handler					)
              library_root_logger.setLevel(_get_default_logging_level()					)
              __UpperCamelCase	=  False
def     lowercase__       (       )			->				None:



       """simple docstring"""






       global _default_handler

       with _lock:
              if not _default_handler:
                     return

              __UpperCamelCase	=  _get_library_root_logger()
              library_root_logger.removeHandler(_default_handler					)
              library_root_logger.setLevel(logging.NOTSET					)
              __UpperCamelCase	=  None
def     lowercase__       (       )			->				str:



       """simple docstring"""






       return log_levels
def     lowercase__       (       __lowercase						:  Optional[str] = None					)			->				logging.Logger:



       """simple docstring"""






       if name is None:
              __UpperCamelCase	=  _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						:  int					)			->				None:



       """simple docstring"""






       _configure_library_root_logger()
       _get_library_root_logger().setLevel(__lowercase					)
def     lowercase__       (       )			->				Tuple:



       """simple docstring"""






       return set_verbosity(__lowercase					)
def     lowercase__       (       )			->				Union[str, Any]:



       """simple docstring"""






       return set_verbosity(__lowercase					)
def     lowercase__       (       )			->				Any:



       """simple docstring"""






       return set_verbosity(__lowercase					)
def     lowercase__       (       )			->				int:



       """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						:  logging.Handler					)			->				None:



       """simple docstring"""






       _configure_library_root_logger()

       assert handler is not None
       _get_library_root_logger().addHandler(__lowercase					)
def     lowercase__       (       __lowercase						:  logging.Handler					)			->				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()
       __UpperCamelCase	=  False
def     lowercase__       (       )			->				None:



       """simple docstring"""






       _configure_library_root_logger()
       __UpperCamelCase	=  True
def     lowercase__       (       )			->				None:



       """simple docstring"""






       __UpperCamelCase	=  _get_library_root_logger().handlers

       for handler in handlers:
              __UpperCamelCase	=  logging.Formatter('[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'					)
              handler.setFormatter(__lowercase					)
def     lowercase__       (       )			->				None:



       """simple docstring"""






       __UpperCamelCase	=  _get_library_root_logger().handlers

       for handler in handlers:
              handler.setFormatter(__lowercase					)
def     lowercase__       (       self						:  int    ,  *__lowercase						:  List[str]    ,  **__lowercase						:  List[Any]					)			->				Any:



       """simple docstring"""






       __UpperCamelCase	=  os.getenv('DIFFUSERS_NO_ADVISORY_WARNINGS'    ,  __lowercase					)
       if no_advisory_warnings:
              return
       self.warning(*__lowercase    ,  **__lowercase					)


a__							:							Dict			=warning_advice

class 					snake_case					:




 """simple docstring"""



 def __init__(	self	:							Optional[int]							,     *__A	:							int							,     **__A	:							Dict     ):  # pylint: disable=unused-argument
        __UpperCamelCase	=  args[0] if args else None






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






 def __getattr__(	self	:							Tuple							,     __A	:							Any     ):

        def empty_fn(*__A	:							Any							,     **__A	:							List[str]     ):  # pylint: disable=unused-argument
               return

        return empty_fn






 def __enter__(	self	:							str     ):
        return self






 def __exit__(	self	:							Optional[Any]							,     __A	:							Dict							,     __A	:							str							,     __A	:							Dict     ):
        return






class 					snake_case					:




 """simple docstring"""



 def __call__(	self	:							Union[str, Any]							,     *__A	:							Union[str, Any]							,     **__A	:							Dict     ):
        if _tqdm_active:
               return tqdm_lib.tqdm(*__A							,     **__A     )
        else:
               return EmptyTqdm(*__A							,     **__A     )






 def 	_lowerCamelCase (	self	:							Any							,     *__A	:							str							,     **__A	:							Optional[int]     ):
        __UpperCamelCase	=  None
        if _tqdm_active:
               return tqdm_lib.tqdm.set_lock(*__A							,     **__A     )






 def 	_lowerCamelCase (	self	:							Optional[int]     ):
        if _tqdm_active:
               return tqdm_lib.tqdm.get_lock()






a__							:							List[Any]			=_tqdm_cls()
def     lowercase__       (       )			->				bool:



       """simple docstring"""






       global _tqdm_active
       return bool(_tqdm_active					)
def     lowercase__       (       )			->				List[str]:



       """simple docstring"""






       global _tqdm_active
       __UpperCamelCase	=  True


def     lowercase__       (       )			->				str:



       """simple docstring"""






       global _tqdm_active
       __UpperCamelCase	=  False
