




import warnings

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


lowerCamelCase__					:  Tuple      							=				logging.get_logger(__name__)

lowerCamelCase__					:  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 			lowerCamelCase_				( _SCREAMING_SNAKE_CASE   ):


 '''simple docstring'''







 lowercase_							       =       "xlnet"
 lowercase_							       =       ["mems"]
 lowercase_							       =       {
     "n_token": "vocab_size",  # Backward compatibility
     "hidden_size": "d_model",
     "num_attention_heads": "n_head",
     "num_hidden_layers": "n_layer",
 }



 def __init__(				self    :						str							,							_lowerCAmelCase    :						Optional[int]=32_000							,							_lowerCAmelCase    :						Optional[Any]=1_024							,							_lowerCAmelCase    :						str=24							,							_lowerCAmelCase    :						Any=16							,							_lowerCAmelCase    :						Union[str, Any]=4_096							,							_lowerCAmelCase    :						List[str]="gelu"							,							_lowerCAmelCase    :						Tuple=True							,							_lowerCAmelCase    :						Optional[int]="bi"							,							_lowerCAmelCase    :						Any=0.02							,							_lowerCAmelCase    :						List[Any]=1E-12							,							_lowerCAmelCase    :						Any=0.1							,							_lowerCAmelCase    :						List[Any]=512							,							_lowerCAmelCase    :						int=None							,							_lowerCAmelCase    :						Dict=True							,							_lowerCAmelCase    :						str=False							,							_lowerCAmelCase    :						str=False							,							_lowerCAmelCase    :						str=-1							,							_lowerCAmelCase    :						Dict=False							,							_lowerCAmelCase    :						int="last"							,							_lowerCAmelCase    :						List[Any]=True							,							_lowerCAmelCase    :						Optional[int]="tanh"							,							_lowerCAmelCase    :						Union[str, Any]=0.1							,							_lowerCAmelCase    :						Any=5							,							_lowerCAmelCase    :						List[Any]=5							,							_lowerCAmelCase    :						Optional[int]=5							,							_lowerCAmelCase    :						Optional[int]=1							,							_lowerCAmelCase    :						Dict=2							,							**_lowerCAmelCase    :						str							,							):
       SCREAMING_SNAKE_CASE_      		=     vocab_size
       SCREAMING_SNAKE_CASE_      		=     d_model
       SCREAMING_SNAKE_CASE_      		=     n_layer
       SCREAMING_SNAKE_CASE_      		=     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})"		)
       SCREAMING_SNAKE_CASE_      		=     d_model // n_head
       SCREAMING_SNAKE_CASE_      		=     ff_activation
       SCREAMING_SNAKE_CASE_      		=     d_inner
       SCREAMING_SNAKE_CASE_      		=     untie_r
       SCREAMING_SNAKE_CASE_      		=     attn_type

       SCREAMING_SNAKE_CASE_      		=     initializer_range
       SCREAMING_SNAKE_CASE_      		=     layer_norm_eps

       SCREAMING_SNAKE_CASE_      		=     dropout
       SCREAMING_SNAKE_CASE_      		=     mem_len
       SCREAMING_SNAKE_CASE_      		=     reuse_len
       SCREAMING_SNAKE_CASE_      		=     bi_data
       SCREAMING_SNAKE_CASE_      		=     clamp_len
       SCREAMING_SNAKE_CASE_      		=     same_length

       SCREAMING_SNAKE_CASE_      		=     summary_type
       SCREAMING_SNAKE_CASE_      		=     summary_use_proj
       SCREAMING_SNAKE_CASE_      		=     summary_activation
       SCREAMING_SNAKE_CASE_      		=     summary_last_dropout
       SCREAMING_SNAKE_CASE_      		=     start_n_top
       SCREAMING_SNAKE_CASE_      		=     end_n_top

       SCREAMING_SNAKE_CASE_      		=     bos_token_id
       SCREAMING_SNAKE_CASE_      		=     pad_token_id
       SCREAMING_SNAKE_CASE_      		=     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.'							,							_lowerCAmelCase							,							)
             SCREAMING_SNAKE_CASE_      		=     kwargs['use_cache']

       SCREAMING_SNAKE_CASE_      		=     use_mems_eval
       SCREAMING_SNAKE_CASE_      		=     use_mems_train
       super().__init__(pad_token_id=_lowerCAmelCase							,							bos_token_id=_lowerCAmelCase							,							eos_token_id=_lowerCAmelCase							,							**_lowerCAmelCase		)



 @property
 def  lowerCAmelCase_    (				self    :						Union[str, Any]		):
       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  lowerCAmelCase_    (				self    :						List[str]							,							_lowerCAmelCase    :						Optional[int]		):
       # 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."		)







import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


A__      :     Tuple       =					{
    '<': operator.lt,
    '<=': operator.le,
    '==': operator.eq,
    '!=': operator.ne,
    '>=': operator.ge,
    '>': operator.gt,
}






def     a     (		lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				if got_ver is None or want_ver is None:
								raise ValueError(
								    F"""Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider"""
								    F""" reinstalling {pkg}."""							)
				if not ops[op](version.parse(lowerCamelCase_							)						,  version.parse(lowerCamelCase_							)							):
								raise ImportError(
								    F"""{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}"""							)






def     a     (		lowerCamelCase_						,  lowerCamelCase_ = None							):






				'''simple docstring'''
				lowercase__  					=     F"""\n{hint}""" if hint is not None else ''''''

				# non-versioned check
				if re.match(r'''^[\w_\-\d]+$'''						,  lowerCamelCase_							):
								lowercase__					,		lowercase__					,		lowercase__  					=     requirement, None, None
				else:
								lowercase__  					=     re.findall(r'''^([^!=<>\s]+)([\s!=<>]{1,2}.+)'''						,  lowerCamelCase_							)
								if not match:
												raise ValueError(
												    '''requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but'''
												    F""" got {requirement}"""							)
								lowercase__					,		lowercase__  					=     match[0]
								lowercase__  					=     want_full.split(''','''							)  # there could be multiple requirements
								lowercase__  					=     {}
								for w in want_range:
												lowercase__  					=     re.findall(r'''^([\s!=<>]{1,2})(.+)'''						,  lowerCamelCase_							)
												if not match:
																raise ValueError(
																    '''requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,'''
																    F""" but got {requirement}"""							)
												lowercase__					,		lowercase__  					=     match[0]
												lowercase__  					=     want_ver
												if op not in ops:
																raise ValueError(F"""{requirement}: need one of {list(ops.keys()							)}, but got {op}"""							)

    # special case
				if pkg == "python":
								lowercase__  					=     '''.'''.join([str(lowerCamelCase_							) for x in sys.version_info[:3]]							)
								for op, want_ver in wanted.items():
												_compare_versions(lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_							)
								return

				# check if any version is installed
				try:
								lowercase__  					=     importlib.metadata.version(lowerCamelCase_							)
				except importlib.metadata.PackageNotFoundError:
								raise importlib.metadata.PackageNotFoundError(
								    F"""The '{requirement}' distribution was not found and is required by this application. {hint}"""							)

				# check that the right version is installed if version number or a range was provided
				if want_ver is not None:
								for op, want_ver in wanted.items():
												_compare_versions(lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_							)






def     a     (		lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     '''Try: pip install transformers -U or pip install -e \'.[dev]\' if you\'re working with git main'''
				return require_version(lowerCamelCase_						,  lowerCamelCase_							)




