



"""simple docstring"""

import argparse
import os
import re

import packaging.version


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







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Dict				,    SCREAMING_SNAKE_CASE__ :  str				,    SCREAMING_SNAKE_CASE__ :  int			):



					"""simple docstring"""





					with open(snake_case_				,    """r"""				,    encoding="""utf-8"""				,    newline="""\n"""			) as f:
										snake_case_					:		Optional[Any] 					=					f.read()
					snake_case_					:		Tuple 					=					REPLACE_PATTERNS[pattern]
					snake_case_					:		Union[str, Any] 					=					replace.replace("""VERSION"""				,    snake_case_			)
					snake_case_					:		Dict 					=					re_pattern.sub(snake_case_				,    snake_case_			)
					with open(snake_case_				,    """w"""				,    encoding="""utf-8"""				,    newline="""\n"""			) as f:
										f.write(snake_case_			)







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Optional[int]			):



					"""simple docstring"""





					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 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Union[str, Any]				,    SCREAMING_SNAKE_CASE__ :  int=False			):



					"""simple docstring"""





					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 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					snake_case_					:		Any 					=					"""🤗 Transformers currently provides the following architectures"""
					snake_case_					:		int 					=					"""1. Want to contribute a new model?"""
					with open(snake_case_				,    """r"""				,    encoding="""utf-8"""				,    newline="""\n"""			) as f:
										snake_case_					:		Union[str, Any] 					=					f.readlines()

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

					snake_case_					:		Any 					=					start_index
					# Update the lines in the model list.
					while not lines[index].startswith(_end_prompt			):
										if lines[index].startswith("""1."""			):
															snake_case_					:		Optional[int] 					=					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 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					with open(REPLACE_FILES["""init"""]				,    """r"""			) as f:
										snake_case_					:		Dict 					=					f.read()
					snake_case_					:		str 					=					REPLACE_PATTERNS["""init"""][0].search(snake_case_			).groups()[0]
					return packaging.version.parse(snake_case_			)







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Optional[Any]=False			):



					"""simple docstring"""





					snake_case_					:		Dict 					=					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:
										snake_case_					:		Optional[Any] 					=					default_version.base_version
					elif patch:
										snake_case_					:		Any 					=					f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
					else:
										snake_case_					:		str 					=					f'{default_version.major}.{default_version.minor + 1}.0'

					# Now let's ask nicely if that's the right one.
					snake_case_					:		Dict 					=					input(f'Which version are you releasing? [{default_version}]'			)
					if len(snake_case_			) == 0:
										snake_case_					:		List[str] 					=					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 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					snake_case_					:		List[str] 					=					get_version()
					snake_case_					:		Union[str, Any] 					=					f'{current_version.major}.{current_version.minor + 1}.0.dev0'
					snake_case_					:		List[str] 					=					current_version.base_version

					# Check with the user we got that right.
					snake_case_					:		Union[str, Any] 					=					input(f'Which version are we developing now? [{dev_version}]'			)
					if len(snake_case_			) == 0:
										snake_case_					:		Union[str, Any] 					=					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__":
			a_				   =					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.''')
			a_				   =					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()









"""simple docstring"""

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import CONFIG_MAPPING


a_			   =					logging.get_logger(__name__)







class    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						_A		:							Optional[int]							       =		"""upernet"""







						def __init__(self   ,		lowercase__=None   ,		lowercase__=5_12   ,		lowercase__=0.02   ,		lowercase__=[1, 2, 3, 6]   ,		lowercase__=True   ,		lowercase__=0.4   ,		lowercase__=3_84   ,		lowercase__=2_56   ,		lowercase__=1   ,		lowercase__=False   ,		lowercase__=2_55   ,		**lowercase__   ,		):
											super().__init__(**lowercase__       )

											if backbone_config is None:
																logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."""       )
																snake_case_					:		List[Any] 					=					CONFIG_MAPPING["""resnet"""](out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]       )
											elif isinstance(lowercase__   ,		lowercase__       ):
																snake_case_					:		Tuple 					=					backbone_config.get("""model_type"""       )
																snake_case_					:		List[str] 					=					CONFIG_MAPPING[backbone_model_type]
																snake_case_					:		List[Any] 					=					config_class.from_dict(lowercase__       )

											snake_case_					:		List[Any] 					=					backbone_config
											snake_case_					:		Optional[Any] 					=					hidden_size
											snake_case_					:		Any 					=					initializer_range
											snake_case_					:		str 					=					pool_scales
											snake_case_					:		Dict 					=					use_auxiliary_head
											snake_case_					:		str 					=					auxiliary_loss_weight
											snake_case_					:		List[str] 					=					auxiliary_in_channels
											snake_case_					:		Optional[Any] 					=					auxiliary_channels
											snake_case_					:		Any 					=					auxiliary_num_convs
											snake_case_					:		List[Any] 					=					auxiliary_concat_input
											snake_case_					:		List[str] 					=					loss_ignore_index







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Dict 					=					copy.deepcopy(self.__dict__       )
											snake_case_					:		Union[str, Any] 					=					self.backbone_config.to_dict()
											snake_case_					:		Any 					=					self.__class__.model_type
											return output




