



'''simple docstring'''





import argparse
import os
import re

import packaging.version


SCREAMING_SNAKE_CASE__       =      '''examples/'''
SCREAMING_SNAKE_CASE__       =      {
    '''examples''': (re.compile(r'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''),
    '''init''': (re.compile(r'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''),
    '''setup''': (re.compile(r'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), r'''\1version="VERSION",'''),
    '''doc''': (re.compile(r'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''),
}
SCREAMING_SNAKE_CASE__       =      {
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
SCREAMING_SNAKE_CASE__       =      '''README.md'''


def A						(       __UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)						->      List[Any]:
			with open(__UpperCamelCase ,	'r' ,	encoding='utf-8' ,	newline='\n'					) as f:
						A__       =    f.read()
			A__     , A__       =    REPLACE_PATTERNS[pattern]
			A__       =    replace.replace('VERSION' ,	__UpperCamelCase					)
			A__       =    re_pattern.sub(__UpperCamelCase ,	__UpperCamelCase					)
			with open(__UpperCamelCase ,	'w' ,	encoding='utf-8' ,	newline='\n'					) as f:
						f.write(__UpperCamelCase					)


def A						(       __UpperCamelCase					)						->      Any:
			for folder, directories, fnames in os.walk(__UpperCamelCase					):
						# Removing some of the folders with non-actively maintained examples from the walk
						if "research_projects" in directories:
									directories.remove('research_projects'					)
						if "legacy" in directories:
									directories.remove('legacy'					)
						for fname in fnames:
									if fname.endswith('.py'					):
												update_version_in_file(os.path.join(__UpperCamelCase ,	__UpperCamelCase					) ,	__UpperCamelCase ,	pattern='examples'					)


def A						(       __UpperCamelCase ,	__UpperCamelCase=False					)						->      int:
			for pattern, fname in REPLACE_FILES.items():
						update_version_in_file(__UpperCamelCase ,	__UpperCamelCase ,	__UpperCamelCase					)
			if not patch:
						update_version_in_examples(__UpperCamelCase					)


def A						(       )						->      Dict:
			A__       =    '🤗 Transformers currently provides the following architectures'
			A__       =    '1. Want to contribute a new model?'
			with open(__UpperCamelCase ,	'r' ,	encoding='utf-8' ,	newline='\n'					) as f:
						A__       =    f.readlines()

			# Find the start of the list.
			A__       =    0
			while not lines[start_index].startswith(_start_prompt					):
						start_index += 1
			start_index += 1

			A__       =    start_index
			# Update the lines in the model list.
			while not lines[index].startswith(_end_prompt					):
						if lines[index].startswith('1.'					):
									A__       =    lines[index].replace(
									    'https://huggingface.co/docs/transformers/main/model_doc' ,	'https://huggingface.co/docs/transformers/model_doc' ,	)
						index += 1

			with open(__UpperCamelCase ,	'w' ,	encoding='utf-8' ,	newline='\n'					) as f:
						f.writelines(__UpperCamelCase					)


def A						(       )						->      Optional[Any]:
			with open(REPLACE_FILES['init'] ,	'r'					) as f:
						A__       =    f.read()
			A__       =    REPLACE_PATTERNS['init'][0].search(__UpperCamelCase					).groups()[0]
			return packaging.version.parse(__UpperCamelCase					)


def A						(       __UpperCamelCase=False					)						->      Tuple:
			A__       =    get_version()
			if patch and default_version.is_devrelease:
						raise ValueError('Can\'t create a patch version from the dev branch, checkout a released version!'					)
			if default_version.is_devrelease:
						A__       =    default_version.base_version
			elif patch:
						A__       =    f'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
			else:
						A__       =    f'''{default_version.major}.{default_version.minor + 1}.0'''

			# Now let's ask nicely if that's the right one.
			A__       =    input(f'''Which version are you releasing? [{default_version}]'''					)
			if len(__UpperCamelCase					) == 0:
						A__       =    default_version

			print(f'''Updating version to {version}.'''					)
			global_version_update(__UpperCamelCase ,	patch=__UpperCamelCase					)
			if not patch:
						print('Cleaning main README, don\'t forget to run `make fix-copies`.'					)
						clean_main_ref_in_model_list()


def A						(       )						->      Union[str, Any]:
			A__       =    get_version()
			A__       =    f'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
			A__       =    current_version.base_version

			# Check with the user we got that right.
			A__       =    input(f'''Which version are we developing now? [{dev_version}]'''					)
			if len(__UpperCamelCase					) == 0:
						A__       =    dev_version

			print(f'''Updating version to {version}.'''					)
			global_version_update(__UpperCamelCase					)
			print('Cleaning main README, don\'t forget to run `make fix-copies`.'					)
			clean_main_ref_in_model_list()


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE__       =      argparse.ArgumentParser()
							parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''')
							parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''')
							SCREAMING_SNAKE_CASE__       =      parser.parse_args()
							if not args.post_release:
														pre_release_work(patch=args.patch)
							elif args.patch:
														print('''Nothing to do after a patch :-)''')
							else:
														post_release_work()









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE__       =      {
    '''configuration_xlm_roberta''': [
        '''XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XLMRobertaConfig''',
        '''XLMRobertaOnnxConfig''',
    ],
}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							SCREAMING_SNAKE_CASE__       =      ['''XLMRobertaTokenizer''']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							SCREAMING_SNAKE_CASE__       =      ['''XLMRobertaTokenizerFast''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							SCREAMING_SNAKE_CASE__       =      [
							    '''XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''XLMRobertaForCausalLM''',
							    '''XLMRobertaForMaskedLM''',
							    '''XLMRobertaForMultipleChoice''',
							    '''XLMRobertaForQuestionAnswering''',
							    '''XLMRobertaForSequenceClassification''',
							    '''XLMRobertaForTokenClassification''',
							    '''XLMRobertaModel''',
							    '''XLMRobertaPreTrainedModel''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							SCREAMING_SNAKE_CASE__       =      [
							    '''TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFXLMRobertaForCausalLM''',
							    '''TFXLMRobertaForMaskedLM''',
							    '''TFXLMRobertaForMultipleChoice''',
							    '''TFXLMRobertaForQuestionAnswering''',
							    '''TFXLMRobertaForSequenceClassification''',
							    '''TFXLMRobertaForTokenClassification''',
							    '''TFXLMRobertaModel''',
							    '''TFXLMRobertaPreTrainedModel''',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							SCREAMING_SNAKE_CASE__       =      [
							    '''FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''FlaxXLMRobertaForMaskedLM''',
							    '''FlaxXLMRobertaForCausalLM''',
							    '''FlaxXLMRobertaForMultipleChoice''',
							    '''FlaxXLMRobertaForQuestionAnswering''',
							    '''FlaxXLMRobertaForSequenceClassification''',
							    '''FlaxXLMRobertaForTokenClassification''',
							    '''FlaxXLMRobertaModel''',
							    '''FlaxXLMRobertaPreTrainedModel''',
							]

if TYPE_CHECKING:
							from .configuration_xlm_roberta import (
							    XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    XLMRobertaConfig,
							    XLMRobertaOnnxConfig,
							)

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_xlm_roberta import XLMRobertaTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_xlm_roberta_fast import XLMRobertaTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xlm_roberta import (
														    XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    XLMRobertaForCausalLM,
														    XLMRobertaForMaskedLM,
														    XLMRobertaForMultipleChoice,
														    XLMRobertaForQuestionAnswering,
														    XLMRobertaForSequenceClassification,
														    XLMRobertaForTokenClassification,
														    XLMRobertaModel,
														    XLMRobertaPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_xlm_roberta import (
														    TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFXLMRobertaForCausalLM,
														    TFXLMRobertaForMaskedLM,
														    TFXLMRobertaForMultipleChoice,
														    TFXLMRobertaForQuestionAnswering,
														    TFXLMRobertaForSequenceClassification,
														    TFXLMRobertaForTokenClassification,
														    TFXLMRobertaModel,
														    TFXLMRobertaPreTrainedModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_xlm_roberta import (
														    FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    FlaxXLMRobertaForCausalLM,
														    FlaxXLMRobertaForMaskedLM,
														    FlaxXLMRobertaForMultipleChoice,
														    FlaxXLMRobertaForQuestionAnswering,
														    FlaxXLMRobertaForSequenceClassification,
														    FlaxXLMRobertaForTokenClassification,
														    FlaxXLMRobertaModel,
														    FlaxXLMRobertaPreTrainedModel,
														)

else:
							import sys

							SCREAMING_SNAKE_CASE__       =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




