




import argparse
import os
import re

import packaging.version


UpperCAmelCase_						="""examples/"""
UpperCAmelCase_						={
    """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"""),
}
UpperCAmelCase_						={
    """init""": """src/transformers/__init__.py""",
    """setup""": """setup.py""",
}
UpperCAmelCase_						="""README.md"""



def       UpperCAmelCase       (     _snake_case						, _snake_case						, _snake_case							):
							with open(_snake_case						, '''r'''						, encoding='''utf-8'''						, newline='''\n'''							) as f:
														lowerCAmelCase   =		f.read()
							lowerCAmelCase   ,     lowerCAmelCase   =		REPLACE_PATTERNS[pattern]
							lowerCAmelCase   =		replace.replace('''VERSION'''						, _snake_case							)
							lowerCAmelCase   =		re_pattern.sub(_snake_case						, _snake_case							)
							with open(_snake_case						, '''w'''						, encoding='''utf-8'''						, newline='''\n'''							) as f:
														f.write(_snake_case							)



def       UpperCAmelCase       (     _snake_case							):
							for folder, directories, fnames in os.walk(_snake_case							):
														# 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(_snake_case						, _snake_case							)						, _snake_case						, pattern='''examples'''							)



def       UpperCAmelCase       (     _snake_case						, _snake_case=False							):
							for pattern, fname in REPLACE_FILES.items():
														update_version_in_file(_snake_case						, _snake_case						, _snake_case							)
							if not patch:
														update_version_in_examples(_snake_case							)



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

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

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

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



def       UpperCAmelCase       (     ):
							with open(REPLACE_FILES['''init''']						, '''r'''							) as f:
														lowerCAmelCase   =		f.read()
							lowerCAmelCase   =		REPLACE_PATTERNS['''init'''][0].search(_snake_case							).groups()[0]
							return packaging.version.parse(_snake_case							)



def       UpperCAmelCase       (     _snake_case=False							):
							lowerCAmelCase   =		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:
														lowerCAmelCase   =		default_version.base_version
							elif patch:
														lowerCAmelCase   =		F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}"""
							else:
														lowerCAmelCase   =		F"""{default_version.major}.{default_version.minor + 1}.0"""

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

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



def       UpperCAmelCase       (     ):
							lowerCAmelCase   =		get_version()
							lowerCAmelCase   =		F"""{current_version.major}.{current_version.minor + 1}.0.dev0"""
							lowerCAmelCase   =		current_version.base_version

							# Check with the user we got that right.
							lowerCAmelCase   =		input(F"""Which version are we developing now? [{dev_version}]"""							)
							if len(_snake_case							) == 0:
														lowerCAmelCase   =		dev_version

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


if __name__ == "__main__":
		UpperCAmelCase_						=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.""")
		UpperCAmelCase_						=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_tf_available,
    is_torch_available,
    is_vision_available,
)


UpperCAmelCase_						={
    """configuration_efficientformer""": [
        """EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """EfficientFormerConfig""",
    ]
}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase_						=["""EfficientFormerImageProcessor"""]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase_						=[
		    """EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """EfficientFormerForImageClassification""",
		    """EfficientFormerForImageClassificationWithTeacher""",
		    """EfficientFormerModel""",
		    """EfficientFormerPreTrainedModel""",
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase_						=[
		    """TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """TFEfficientFormerForImageClassification""",
		    """TFEfficientFormerForImageClassificationWithTeacher""",
		    """TFEfficientFormerModel""",
		    """TFEfficientFormerPreTrainedModel""",
		]

if TYPE_CHECKING:
		from .configuration_efficientformer import EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, EfficientFormerConfig

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .image_processing_efficientformer import EfficientFormerImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_efficientformer import (
				    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    EfficientFormerForImageClassification,
				    EfficientFormerForImageClassificationWithTeacher,
				    EfficientFormerModel,
				    EfficientFormerPreTrainedModel,
				)
		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_efficientformer import (
				    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFEfficientFormerForImageClassification,
				    TFEfficientFormerForImageClassificationWithTeacher,
				    TFEfficientFormerModel,
				    TFEfficientFormerPreTrainedModel,
				)

else:
		import sys

		UpperCAmelCase_						=_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



