



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__    (    lowercase__						,       lowercase__						,       lowercase__   ) ->      Tuple:





						with open(UpperCamelCase__						,       """r"""						,       encoding="""utf-8"""						,       newline="""\n"""   ) as f:
												__lowercase					=				f.read()
						__lowercase	,			__lowercase					=				REPLACE_PATTERNS[pattern]
						__lowercase					=				replace.replace("""VERSION"""						,       UpperCamelCase__   )
						__lowercase					=				re_pattern.sub(UpperCamelCase__						,       UpperCamelCase__   )
						with open(UpperCamelCase__						,       """w"""						,       encoding="""utf-8"""						,       newline="""\n"""   ) as f:
												f.write(UpperCamelCase__   )






def  UpperCAmelCase__    (    lowercase__   ) ->      List[str]:





						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  UpperCAmelCase__    (    lowercase__						,       lowercase__=False   ) ->      str:





						for pattern, fname in REPLACE_FILES.items():
												update_version_in_file(UpperCamelCase__						,       UpperCamelCase__						,       UpperCamelCase__   )
						if not patch:
												update_version_in_examples(UpperCamelCase__   )






def  UpperCAmelCase__    (    ) ->      Optional[int]:
						__lowercase					=				"""🤗 Transformers currently provides the following architectures"""
						__lowercase					=				"""1. Want to contribute a new model?"""
						with open(UpperCamelCase__						,       """r"""						,       encoding="""utf-8"""						,       newline="""\n"""   ) as f:
												__lowercase					=				f.readlines()

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

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





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






def  UpperCAmelCase__    (    lowercase__=False   ) ->      Optional[int]:
						__lowercase					=				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:
												__lowercase					=				default_version.base_version
						elif patch:
												__lowercase					=				F"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
						else:
												__lowercase					=				F"{default_version.major}.{default_version.minor + 1}.0"

						# Now let's ask nicely if that's the right one.
						__lowercase					=				input(F"Which version are you releasing? [{default_version}]"   )
						if len(UpperCamelCase__   ) == 0:
												__lowercase					=				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  UpperCAmelCase__    (    ) ->      Optional[int]:
						__lowercase					=				get_version()
						__lowercase					=				F"{current_version.major}.{current_version.minor + 1}.0.dev0"
						__lowercase					=				current_version.base_version

						# Check with the user we got that right.
						__lowercase					=				input(F"Which version are we developing now? [{dev_version}]"   )
						if len(UpperCamelCase__   ) == 0:
												__lowercase					=				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__":
			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 collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCamelCase__ =						logging.get_logger(__name__)

UpperCamelCase__ =						{
    "hustvl/yolos-small": "https://huggingface.co/hustvl/yolos-small/resolve/main/config.json",
    # See all YOLOS models at https://huggingface.co/models?filter=yolos
}
class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  Union[str, Any]      =			"""yolos"""





			def __init__(				self	:       Optional[int]			,     lowercase	:       Any=768			,     lowercase	:       Tuple=12			,     lowercase	:       Tuple=12			,     lowercase	:       str=3_072			,     lowercase	:       Optional[Any]="gelu"			,     lowercase	:       Union[str, Any]=0.0			,     lowercase	:       Dict=0.0			,     lowercase	:       Optional[int]=0.02			,     lowercase	:       Optional[Any]=1E-1_2			,     lowercase	:       Tuple=[512, 864]			,     lowercase	:       Optional[int]=16			,     lowercase	:       Dict=3			,     lowercase	:       Optional[Any]=True			,     lowercase	:       Optional[int]=100			,     lowercase	:       Optional[int]=True			,     lowercase	:       Any=False			,     lowercase	:       Any=1			,     lowercase	:       Any=5			,     lowercase	:       List[str]=2			,     lowercase	:       Union[str, Any]=5			,     lowercase	:       str=2			,     lowercase	:       Tuple=0.1			,     **lowercase	:       str			,     )						->					Optional[Any]:
									"""simple docstring"""







									super().__init__(**lowercase   )

									__lowercase					=				hidden_size
									__lowercase					=				num_hidden_layers
									__lowercase					=				num_attention_heads
									__lowercase					=				intermediate_size
									__lowercase					=				hidden_act
									__lowercase					=				hidden_dropout_prob
									__lowercase					=				attention_probs_dropout_prob
									__lowercase					=				initializer_range
									__lowercase					=				layer_norm_eps
									__lowercase					=				image_size
									__lowercase					=				patch_size
									__lowercase					=				num_channels
									__lowercase					=				qkv_bias
									__lowercase					=				num_detection_tokens
									__lowercase					=				use_mid_position_embeddings
									__lowercase					=				auxiliary_loss
									# Hungarian matcher
									__lowercase					=				class_cost
									__lowercase					=				bbox_cost
									__lowercase					=				giou_cost
									# Loss coefficients
									__lowercase					=				bbox_loss_coefficient
									__lowercase					=				giou_loss_coefficient
									__lowercase					=				eos_coefficient





class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  Dict      =			version.parse("""1.11"""			)





			@property
			def 		snake_case__			(				self	:       List[str]   )						->					Mapping[str, Mapping[int, str]]:
									"""simple docstring"""







									return OrderedDict(
									    [
									        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
									    ]   )





			@property
			def 		snake_case__			(				self	:       int   )						->					float:
									"""simple docstring"""







									return 1E-4







			@property
			def 		snake_case__			(				self	:       Optional[Any]   )						->					int:
									"""simple docstring"""







									return 12





