

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

import packaging.version


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







def  _A		(     snake_case		,							snake_case		,							snake_case					)      ->     int:

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







def  _A		(     snake_case					)      ->     List[Any]:

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







def  _A		(     snake_case		,							snake_case=False					)      ->     int:

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







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

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

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

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







def  _A		(     )      ->     List[str]:

   with open(REPLACE_FILES["init"]		,							"r"					) as f:
      _lowercase      :				Optional[Any]      					=       f.read()
   _lowercase      :				Optional[Any]      					=       REPLACE_PATTERNS['''init'''][0].search(__a					).groups()[0]
   return packaging.version.parse(__a					)







def  _A		(     snake_case=False					)      ->     str:
   _lowercase      :				Optional[Any]      					=       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      :				List[Any]      					=       default_version.base_version
   elif patch:
      _lowercase      :				str      					=       F'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
   else:
      _lowercase      :				List[str]      					=       F'''{default_version.major}.{default_version.minor + 1}.0'''

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

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







def  _A		(     )      ->     Tuple:
   _lowercase      :				str      					=       get_version()
   _lowercase      :				int      					=       F'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
   _lowercase      :				List[Any]      					=       current_version.base_version

   # Check with the user we got that right.
   _lowercase      :				Union[str, Any]      					=       input(F'''Which version are we developing now? [{dev_version}]'''					)
   if len(__a					) == 0:
      _lowercase      :				List[str]      					=       dev_version

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


if __name__ == "__main__":
    _snake_case         =  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.')
    _snake_case         =  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 ...configuration_utils import PretrainedConfig
from ...utils import logging


_snake_case         =  logging.get_logger(__name__)

_snake_case         =  {
    'weiweishi/roc-bert-base-zh': 'https://huggingface.co/weiweishi/roc-bert-base-zh/resolve/main/config.json',
}


class        a__  (							lowerCamelCase_  ):
   _SCREAMING_SNAKE_CASE   :					Any     	=							'roc_bert'


   def __init__(			self      ,    _UpperCamelCase=30522      ,    _UpperCamelCase=768      ,    _UpperCamelCase=12      ,    _UpperCamelCase=12      ,    _UpperCamelCase=3072      ,    _UpperCamelCase="gelu"      ,    _UpperCamelCase=0.1      ,    _UpperCamelCase=0.1      ,    _UpperCamelCase=512      ,    _UpperCamelCase=2      ,    _UpperCamelCase=0.0_2      ,    _UpperCamelCase=1E-1_2      ,    _UpperCamelCase=True      ,    _UpperCamelCase=0      ,    _UpperCamelCase="absolute"      ,    _UpperCamelCase=None      ,    _UpperCamelCase=True      ,    _UpperCamelCase=True      ,    _UpperCamelCase=768      ,    _UpperCamelCase=910      ,    _UpperCamelCase=512      ,    _UpperCamelCase=24858      ,    _UpperCamelCase=True      ,    **_UpperCamelCase      ,    ):





      """simple docstring"""





      _lowercase      :				str      					=       vocab_size
      _lowercase      :				List[str]      					=       max_position_embeddings
      _lowercase      :				List[Any]      					=       hidden_size
      _lowercase      :				Dict      					=       num_hidden_layers
      _lowercase      :				str      					=       num_attention_heads
      _lowercase      :				int      					=       intermediate_size
      _lowercase      :				Optional[Any]      					=       hidden_act
      _lowercase      :				Union[str, Any]      					=       hidden_dropout_prob
      _lowercase      :				Dict      					=       attention_probs_dropout_prob
      _lowercase      :				Dict      					=       initializer_range
      _lowercase      :				List[Any]      					=       type_vocab_size
      _lowercase      :				Tuple      					=       layer_norm_eps
      _lowercase      :				Optional[int]      					=       use_cache
      _lowercase      :				Tuple      					=       enable_pronunciation
      _lowercase      :				Optional[int]      					=       enable_shape
      _lowercase      :				int      					=       pronunciation_embed_dim
      _lowercase      :				List[str]      					=       pronunciation_vocab_size
      _lowercase      :				int      					=       shape_embed_dim
      _lowercase      :				str      					=       shape_vocab_size
      _lowercase      :				str      					=       concat_input
      _lowercase      :				Dict      					=       position_embedding_type
      _lowercase      :				Optional[Any]      					=       classifier_dropout
      super().__init__(pad_token_id=_UpperCamelCase      ,    **_UpperCamelCase  )






