import warnings

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


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

a  :      Optional[int]            =    {
    'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/config.json',
    'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/config.json',
}

class 					_lowercase    (     UpperCAmelCase__			):






    '''simple docstring'''
    SCREAMING_SNAKE_CASE:				int          =    'xlnet'
    SCREAMING_SNAKE_CASE:				str          =    ['mems']
    SCREAMING_SNAKE_CASE:				Any          =    {
        'n_token': 'vocab_size',  # Backward compatibility
        'hidden_size': 'd_model',
        'num_attention_heads': 'n_head',
        'num_hidden_layers': 'n_layer',
    }




    def __init__(    self       ,						lowerCamelCase__=32_000       ,						lowerCamelCase__=1_024       ,						lowerCamelCase__=24       ,						lowerCamelCase__=16       ,						lowerCamelCase__=4_096       ,						lowerCamelCase__="gelu"       ,						lowerCamelCase__=True       ,						lowerCamelCase__="bi"       ,						lowerCamelCase__=0.0_2       ,						lowerCamelCase__=1E-12       ,						lowerCamelCase__=0.1       ,						lowerCamelCase__=512       ,						lowerCamelCase__=None       ,						lowerCamelCase__=True       ,						lowerCamelCase__=False       ,						lowerCamelCase__=False       ,						lowerCamelCase__=-1       ,						lowerCamelCase__=False       ,						lowerCamelCase__="last"       ,						lowerCamelCase__=True       ,						lowerCamelCase__="tanh"       ,						lowerCamelCase__=0.1       ,						lowerCamelCase__=5       ,						lowerCamelCase__=5       ,						lowerCamelCase__=5       ,						lowerCamelCase__=1       ,						lowerCamelCase__=2       ,						**lowerCamelCase__       ,						):
       lowerCAmelCase_:							Union[str, Any]       =	vocab_size
       lowerCAmelCase_:							Tuple       =	d_model
       lowerCAmelCase_:							List[Any]       =	n_layer
       lowerCAmelCase_:							Dict       =	n_head
       if d_model % n_head != 0:
          raise ValueError(F'''\'d_model % n_head\' ({d_model % n_head}) should be equal to 0''' )
       if "d_head" in kwargs:
          if kwargs["d_head"] != d_model // n_head:
             raise ValueError(
                 F'''`d_head` ({kwargs["d_head"]}) should be equal to `d_model // n_head` ({d_model // n_head})''' )
       lowerCAmelCase_:							Tuple       =	d_model // n_head
       lowerCAmelCase_:							Any       =	ff_activation
       lowerCAmelCase_:							Any       =	d_inner
       lowerCAmelCase_:							Optional[int]       =	untie_r
       lowerCAmelCase_:							Union[str, Any]       =	attn_type

       lowerCAmelCase_:							Union[str, Any]       =	initializer_range
       lowerCAmelCase_:							Optional[int]       =	layer_norm_eps

       lowerCAmelCase_:							str       =	dropout
       lowerCAmelCase_:							List[Any]       =	mem_len
       lowerCAmelCase_:							Any       =	reuse_len
       lowerCAmelCase_:							Union[str, Any]       =	bi_data
       lowerCAmelCase_:							Dict       =	clamp_len
       lowerCAmelCase_:							List[str]       =	same_length

       lowerCAmelCase_:							Any       =	summary_type
       lowerCAmelCase_:							Tuple       =	summary_use_proj
       lowerCAmelCase_:							Dict       =	summary_activation
       lowerCAmelCase_:							List[str]       =	summary_last_dropout
       lowerCAmelCase_:							int       =	start_n_top
       lowerCAmelCase_:							int       =	end_n_top

       lowerCAmelCase_:							Union[str, Any]       =	bos_token_id
       lowerCAmelCase_:							List[Any]       =	pad_token_id
       lowerCAmelCase_:							List[str]       =	eos_token_id

       if "use_cache" in kwargs:
          warnings.warn(
              "The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`"
              " instead."       ,						A_       ,						)
          lowerCAmelCase_:							List[str]       =	kwargs["use_cache"]

       lowerCAmelCase_:							Tuple       =	use_mems_eval
       lowerCAmelCase_:							Tuple       =	use_mems_train
       super().__init__(pad_token_id=A_       ,						bos_token_id=A_       ,						eos_token_id=A_       ,						**A_ )




    @property
    def      _a    (    self ):
       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      _a    (    self       ,						lowerCamelCase__ ):
       # Message copied from Transformer-XL documentation
       raise NotImplementedError(
           F'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )



"""simple docstring"""




__magic_name__						: Optional[Any]    =				'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'





def       a_ (	lowercase__ :bytes     ):
			# Make sure the supplied data is a bytes-like object
			if not isinstance(lowercase__,			lowercase__     ):
						__lowerCamelCase          =      f'a bytes-like object is required, not \'{data.__class__.__name__}\''
						raise TypeError(lowercase__     )

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

			__lowerCamelCase          =      len(lowercase__     ) % 6 != 0

			if padding_needed:
						# The padding that will be added later
						__lowerCamelCase          =      B"""=""" * ((6 - len(lowercase__     ) % 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(lowercase__     ) % 6)
			else:
						__lowerCamelCase          =      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(lowercase__     ),			6     )     ).encode()
			    + padding
			)





def       a_ (	lowercase__ :str     ):
			# Make sure encoded_data is either a string or a bytes-like object
			if not isinstance(lowercase__,			lowercase__     ) and not isinstance(lowercase__,			lowercase__     ):
						__lowerCamelCase          =      (
						    """argument should be a bytes-like object or ASCII string, """
						    f'not \'{encoded_data.__class__.__name__}\''
						)
						raise TypeError(lowercase__     )

			# 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(lowercase__,			lowercase__     ):
						try:
									__lowerCamelCase          =      encoded_data.decode("""utf-8"""     )
						except UnicodeDecodeError:
									raise ValueError("""base64 encoded data should only contain ASCII characters"""     )

			__lowerCamelCase          =      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(lowercase__     ) % 4 == 0 and padding < 3, "Incorrect padding"

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

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

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

			return bytes(lowercase__     )


if __name__ == "__main__":
					import doctest

					doctest.testmod()




