"""simple docstring"""


from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase_:					Tuple     =					logging.get_logger(__name__)

lowerCAmelCase_:					str     =					{
    "transfo-xl-wt103": "https://huggingface.co/transfo-xl-wt103/resolve/main/config.json",
}






class    a__    (   _a	):
   snake_case_							=      "transfo-xl"
   snake_case_							=      ["mems"]
   snake_case_							=      {
       "n_token": "vocab_size",
       "hidden_size": "d_model",
       "num_attention_heads": "n_head",
       "num_hidden_layers": "n_layer",
   }


   def __init__(     self,				_UpperCAmelCase=26_7735,				_UpperCAmelCase=[2_0000, 4_0000, 20_0000],				_UpperCAmelCase=1024,				_UpperCAmelCase=1024,				_UpperCAmelCase=16,				_UpperCAmelCase=64,				_UpperCAmelCase=4096,				_UpperCAmelCase=4,				_UpperCAmelCase=False,				_UpperCAmelCase=18,				_UpperCAmelCase=1600,				_UpperCAmelCase=1000,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=0,				_UpperCAmelCase=-1,				_UpperCAmelCase=True,				_UpperCAmelCase=0.1,				_UpperCAmelCase=0.0,				_UpperCAmelCase=True,				_UpperCAmelCase="normal",				_UpperCAmelCase=0.01,				_UpperCAmelCase=0.01,				_UpperCAmelCase=0.02,				_UpperCAmelCase=1E-5,				_UpperCAmelCase=0,				**_UpperCAmelCase,				):
        '''simple docstring'''



        lowercase__				 =							vocab_size
        lowercase__				 =							[]
        self.cutoffs.extend(_UpperCAmelCase  )
        if proj_share_all_but_first:
             lowercase__				 =							[False] + [True] * len(self.cutoffs  )
        else:
             lowercase__				 =							[False] + [False] * len(self.cutoffs  )
        lowercase__				 =							d_model
        lowercase__				 =							d_embed
        lowercase__				 =							d_head
        lowercase__				 =							d_inner
        lowercase__				 =							div_val
        lowercase__				 =							pre_lnorm
        lowercase__				 =							n_layer
        lowercase__				 =							n_head
        lowercase__				 =							mem_len
        lowercase__				 =							same_length
        lowercase__				 =							attn_type
        lowercase__				 =							clamp_len
        lowercase__				 =							sample_softmax
        lowercase__				 =							adaptive
        lowercase__				 =							dropout
        lowercase__				 =							dropatt
        lowercase__				 =							untie_r
        lowercase__				 =							init
        lowercase__				 =							init_range
        lowercase__				 =							proj_init_std
        lowercase__				 =							init_std
        lowercase__				 =							layer_norm_epsilon
        super().__init__(eos_token_id=_UpperCAmelCase,				**_UpperCAmelCase  )


   @property
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        logger.info(F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''  )
        return -1


   @max_position_embeddings.setter
   def 	snake_case__	(     self,				_UpperCAmelCase  ):
        '''simple docstring'''



        raise NotImplementedError(
            F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''  )





"""simple docstring"""


lowerCAmelCase_:					Any     =					"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"







def 					__a   (		A      ):






     '''simple docstring'''



     if not isinstance(A    ,				A      ):
          lowercase__				 =							f'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
          raise TypeError(A      )

     lowercase__				 =							"".join(bin(A      )[2:].zfill(8      ) for byte in data      )

     lowercase__				 =							len(A      ) % 6 != 0

     if padding_needed:
          # The padding that will be added later
          lowercase__				 =							b"=" * ((6 - len(A      ) % 6) // 2)

          # Append binary_stream with arbitrary binary digits (0's by default) to make its
          # length a multiple of 6.
          binary_stream += "0" * (6 - len(A      ) % 6)
     else:
          lowercase__				 =							b""

     # Encode every 6 binary digits to their corresponding Base64 character
     return (
         "".join(
             B64_CHARSET[int(binary_stream[index : index + 6]    ,				2      )]
             for index in range(0    ,				len(A      )    ,				6      )      ).encode()
         + padding
     )







def 					__a   (		A      ):






     '''simple docstring'''



     if not isinstance(A    ,				A      ) and not isinstance(A    ,				A      ):
          lowercase__				 =							(
              "argument should be a bytes-like object or ASCII string, "
              f'''not \'{encoded_data.__class__.__name__}\''''
          )
          raise TypeError(A      )

     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object
     if isinstance(A    ,				A      ):
          try:
               lowercase__				 =							encoded_data.decode("utf-8"      )
          except UnicodeDecodeError:
               raise ValueError("base64 encoded data should only contain ASCII characters"      )

     lowercase__				 =							encoded_data.count("="      )

     # Check if the encoded string contains non base64 characters
     if padding:
          assert all(
              char in B64_CHARSET for char in encoded_data[:-padding]      ), "Invalid base64 character(s) found."
     else:
          assert all(
              char in B64_CHARSET for char in encoded_data      ), "Invalid base64 character(s) found."

     # Check the padding
     assert len(A      ) % 4 == 0 and padding < 3, "Incorrect padding"

     if padding:
          # Remove padding if there is one
          lowercase__				 =							encoded_data[:-padding]

          lowercase__				 =							"".join(
              bin(B64_CHARSET.index(A      )      )[2:].zfill(6      ) for char in encoded_data      )[: -padding * 2]
     else:
          lowercase__				 =							"".join(
              bin(B64_CHARSET.index(A      )      )[2:].zfill(6      ) for char in encoded_data      )

     lowercase__				 =							[
         int(binary_stream[index : index + 8]    ,				2      )
         for index in range(0    ,				len(A      )    ,				8      )
     ]

     return bytes(A      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()




