

'''simple docstring'''




import posixpath
from pathlib import Path
from unittest.mock import patch

import pytest
from fsspec.implementations.local import AbstractFileSystem, LocalFileSystem, stringify_path
from fsspec.registry import _registry as _fsspec_registry



class        lowercase_	(		__UpperCAmelCase ):

  '''simple docstring'''





  __lowerCAmelCase					: Union[str, Any]      =   "mock"
  def __init__(     self   , *a_   , a_   , **a_     )							->				Dict:


    """simple docstring"""
    super().__init__()
    UpperCAmelCase													=	LocalFileSystem(*lowercase_   , **lowercase_     )
    UpperCAmelCase													=	Path(lowercase_     ).resolve().as_posix() + '''/'''
  def 						snake_case_			(     self   , a_   , *a_   , **a_     )							->				int:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.mkdir(lowercase_   , *lowercase_   , **lowercase_     )
  def 						snake_case_			(     self   , a_   , *a_   , **a_     )							->				int:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.makedirs(lowercase_   , *lowercase_   , **lowercase_     )
  def 						snake_case_			(     self   , a_     )							->				Union[str, Any]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.rmdir(lowercase_     )
  def 						snake_case_			(     self   , a_   , a_=True   , *a_   , **a_     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    UpperCAmelCase													=	self._fs.ls(lowercase_   , detail=lowercase_   , *lowercase_   , **lowercase_     )
    if detail:
      return [{**info, "name": info["name"][len(self.local_root_dir     ) :]} for info in out]
    else:
      return [name[len(self.local_root_dir     ) :] for name in out]
  def 						snake_case_			(     self   , a_   , *a_   , **a_     )							->				Union[str, Any]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    UpperCAmelCase													=	dict(self._fs.info(lowercase_   , *lowercase_   , **lowercase_     )     )
    UpperCAmelCase													=	out['''name'''][len(self.local_root_dir     ) :]
    return out
  def 						snake_case_			(     self   , a_   , a_   , *a_   , **a_     )							->				Any:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.cp_file(lowercase_   , lowercase_   , *lowercase_   , **lowercase_     )
  def 						snake_case_			(     self   , a_   , *a_   , **a_     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.rm_file(lowercase_   , *lowercase_   , **lowercase_     )
  def 						snake_case_			(     self   , a_   , *a_   , **a_     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.rm(lowercase_   , *lowercase_   , **lowercase_     )
  def 						snake_case_			(     self   , a_   , *a_   , **a_     )							->				Union[str, Any]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs._open(lowercase_   , *lowercase_   , **lowercase_     )
  def 						snake_case_			(     self   , a_     )							->				Optional[Any]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.created(lowercase_     )
  def 						snake_case_			(     self   , a_     )							->				List[str]:


    """simple docstring"""
    UpperCAmelCase													=	posixpath.join(self.local_root_dir   , self._strip_protocol(lowercase_     )     )
    return self._fs.modified(lowercase_     )





  @classmethod
  def 						snake_case_			(     cls   , a_     )							->				Optional[Any]:


    """simple docstring"""
    UpperCAmelCase													=	stringify_path(lowercase_     )
    if path.startswith('mock://'     ):
      UpperCAmelCase													=	path[7:]
    return path




class        lowercase_	(		__UpperCAmelCase ):

  '''simple docstring'''





  __lowerCAmelCase					: Union[str, Any]      =   "tmp"
  __lowerCAmelCase					: Optional[Any]      =   None
  def __init__(     self   , *a_   , **a_     )							->				Dict:


    """simple docstring"""
    assert self.tmp_dir is not None, "TmpDirFileSystem.tmp_dir is not set"
    super().__init__(*lowercase_   , **lowercase_   , local_root_dir=self.tmp_dir   , auto_mkdir=lowercase_     )





  @classmethod
  def 						snake_case_			(     cls   , a_     )							->				Dict:


    """simple docstring"""
    UpperCAmelCase													=	stringify_path(lowercase_     )
    if path.startswith('tmp://'     ):
      UpperCAmelCase													=	path[6:]
    return path




@pytest.fixture
def       lowerCamelCase__		(						):
  UpperCAmelCase													=	MockFileSystem
  UpperCAmelCase													=	TmpDirFileSystem
  yield
  del _fsspec_registry["mock"]
  del _fsspec_registry["tmp"]


@pytest.fixture
def       lowerCamelCase__		(						SCREAMING_SNAKE_CASE      :   Any       ,   SCREAMING_SNAKE_CASE      :   str						):
  UpperCAmelCase													=	tmp_path_factory.mktemp('mockfs'						)
  return MockFileSystem(local_root_dir=lowercase_       ,   auto_mkdir=lowercase_						)



@pytest.fixture
def       lowerCamelCase__		(						SCREAMING_SNAKE_CASE      :   Any       ,   SCREAMING_SNAKE_CASE      :   Optional[Any]						):
  UpperCAmelCase													=	tmp_path_factory.mktemp('tmpfs'						)
  with patch.object(lowercase_       ,   'tmp_dir'       ,   lowercase_						):
    yield TmpDirFileSystem()






'''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[int] 							=						logging.get_logger(__name__)

_a				: Dict 							=						{
    'mnaylor/mega-base-wikitext': 'https://huggingface.co/mnaylor/mega-base-wikitext/resolve/main/config.json',
}



class        lowercase_	(		a ):

  '''simple docstring'''





  __lowerCAmelCase					: List[str]      =   "mega"
  def __init__(     self   , a_=3_0_5_2_2   , a_=1_2_8   , a_=4   , a_=2_5_6   , a_=1_6   , a_=True   , a_=6_4   , a_=False   , a_=-1   , a_=None   , a_=True   , a_="scalenorm"   , a_=True   , a_="silu"   , a_="softmax"   , a_=0.1   , a_=0.1   , a_=0.1   , a_=False   , a_=True   , a_=2_5_6   , a_=True   , a_=0.1   , a_=2_0_4_8   , a_=False   , a_=2   , a_=0.02   , a_=0.2   , a_=0.02   , a_=1.0   , a_=1   , a_=0   , a_=2   , a_="rotary"   , a_=None   , a_=True   , a_=True   , **a_   , )							->				Any:


    """simple docstring"""
    super().__init__(pad_token_id=a_   , bos_token_id=a_   , eos_token_id=a_   , **a_     )

    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        lowercase_	(		a ):

  '''simple docstring'''





  @property
  def 						snake_case_			(     self     )							->				Mapping[str, Mapping[int, str]]:


    """simple docstring"""
    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),
        ]     )


