

'''simple docstring'''
import argparse
import os
import re

import packaging.version


_UpperCAmelCase  :		Tuple  =		'''examples/'''
_UpperCAmelCase  :		Union[str, Any]  =		{
    '''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  :		Tuple  =		{
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
_UpperCAmelCase  :		List[str]  =		'''README.md'''




def 	UpperCamelCase   (       lowercase_						:    Union[str, Any]     ,					lowercase_						:    Tuple     ,					lowercase_						:    int	)		->	Any:




  '''simple docstring'''



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




def 	UpperCamelCase   (       lowercase_						:    Tuple	)		->	int:




  '''simple docstring'''



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




def 	UpperCamelCase   (       lowercase_						:    int     ,					lowercase_						:    Any=False	)		->	Optional[Any]:




  '''simple docstring'''



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




def 	UpperCamelCase   (       )		->	Optional[Any]:




  '''simple docstring'''



  lowercase									='''🤗 Transformers currently provides the following architectures'''
  lowercase									='''1. Want to contribute a new model?'''
  with open(lowercase_     ,					'''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(lowercase_     ,					'''w'''     ,					encoding='''utf-8'''     ,					newline='''\n'''	) as f:
    f.writelines(lowercase_	)




def 	UpperCamelCase   (       )		->	List[str]:




  '''simple docstring'''



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




def 	UpperCamelCase   (       lowercase_						:    int=False	)		->	Dict:




  '''simple docstring'''



  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(lowercase_	) == 0:
    lowercase									=default_version

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




def 	UpperCamelCase   (       )		->	int:




  '''simple docstring'''



  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(lowercase_	) == 0:
    lowercase									=dev_version

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


if __name__ == "__main__":
     _UpperCAmelCase  :		int  =		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  :		int  =		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"""




from itertools import permutations







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		if num[3] % 2 != 0:
				return False

		if (num[2] + num[3] + num[4]) % 3 != 0:
				return False

		if num[5] % 5 != 0:
				return False

		lowerCAmelCase__   = [7, 11, 13, 17]
		for i, test in enumerate(lowerCamelCase__  ):
				if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
						return False
		return True







def 				_UpperCAmelCase		(							lowerCamelCase__ = 10  ):





		"""simple docstring"""




		return sum(
		    int("""""".join(map(lowerCamelCase__      ,	lowerCamelCase__  )  )  )
		    for num in permutations(range(lowerCamelCase__  )  )
		    if is_substring_divisible(lowerCamelCase__  )  )


if __name__ == "__main__":
			print(F"{solution() = }")




