


'''simple docstring'''






import argparse
import os
import re

import packaging.version


a_   :      Tuple				    =      "examples/"
a_   :      Dict				    =      {
    "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_   :      Dict				    =      {
    "init": "src/transformers/__init__.py",
    "setup": "setup.py",
}
a_   :      List[Any]				    =      "README.md"






def 		_A			(lowerCAmelCase__					:Dict			,  lowerCAmelCase__					:Optional[Any]			,  lowerCAmelCase__					:Optional[int]						)				->					Optional[Any]:




     '''simple docstring'''



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






def 		_A			(lowerCAmelCase__					:int						)				->					Optional[Any]:




     '''simple docstring'''



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






def 		_A			(lowerCAmelCase__					:Dict			,  lowerCAmelCase__					:List[Any]=False						)				->					List[Any]:




     '''simple docstring'''



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






def 		_A			()				->					str:




     '''simple docstring'''



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






def 		_A			()				->					Optional[int]:




     '''simple docstring'''



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






def 		_A			(lowerCAmelCase__					:Any=False						)				->					Any:




     '''simple docstring'''



     _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(lowerCAmelCase__						) == 0:
          _a      =							default_version

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






def 		_A			()				->					Optional[Any]:




     '''simple docstring'''



     _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(lowerCAmelCase__						) == 0:
          _a      =							dev_version

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


if __name__ == "__main__":
 a_   :      Optional[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.")
 a_   :      Optional[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'''






import pytest
import requests

from datasets.utils.file_utils import http_head

from .utils import OfflineSimulationMode, RequestWouldHangIndefinitelyError, offline






@pytest.mark.integration
def 		_A			()				->					Optional[Any]:




     '''simple docstring'''



     with offline(OfflineSimulationMode.CONNECTION_TIMES_OUT						):
          with pytest.raises(lowerCAmelCase__						):
               requests.request('GET'			,  'https://huggingface.co'						)
          with pytest.raises(requests.exceptions.ConnectTimeout						):
               requests.request('GET'			,  'https://huggingface.co'			,  timeout=1.0						)






@pytest.mark.integration
def 		_A			()				->					Any:




     '''simple docstring'''



     with offline(OfflineSimulationMode.CONNECTION_FAILS						):
          with pytest.raises(requests.exceptions.ConnectionError						):
               requests.request('GET'			,  'https://huggingface.co'						)






def 		_A			()				->					Dict:




     '''simple docstring'''



     with offline(OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1						):
          with pytest.raises(lowerCAmelCase__						):
               http_head('https://huggingface.co'						)

