






import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase     :							Tuple    =logging.get_logger(__name__)

lowerCamelCase     :							Optional[Any]    ={
    'asapp/sew-tiny-100k': 'https://huggingface.co/asapp/sew-tiny-100k/resolve/main/config.json',
    # See all SEW models at https://huggingface.co/models?filter=sew
}





class       __a  (   _lowerCamelCase	):
 _lowerCAmelCase	:	Tuple				=			'''sew'''







 def __init__(		self :       Optional[Any]							,       SCREAMING_SNAKE_CASE :       Any=32							,       SCREAMING_SNAKE_CASE :       Dict=7_68							,       SCREAMING_SNAKE_CASE :       str=12							,       SCREAMING_SNAKE_CASE :       Union[str, Any]=12							,       SCREAMING_SNAKE_CASE :       List[str]=30_72							,       SCREAMING_SNAKE_CASE :       List[str]=2							,       SCREAMING_SNAKE_CASE :       List[Any]="gelu"							,       SCREAMING_SNAKE_CASE :       Tuple=0.1							,       SCREAMING_SNAKE_CASE :       List[Any]=0.1							,       SCREAMING_SNAKE_CASE :       Optional[int]=0.1							,       SCREAMING_SNAKE_CASE :       Union[str, Any]=0.0							,       SCREAMING_SNAKE_CASE :       Tuple=0.1							,       SCREAMING_SNAKE_CASE :       Any=0.1							,       SCREAMING_SNAKE_CASE :       List[Any]=0.0_2							,       SCREAMING_SNAKE_CASE :       List[str]=1e-5							,       SCREAMING_SNAKE_CASE :       List[str]="group"							,       SCREAMING_SNAKE_CASE :       Dict="gelu"							,       SCREAMING_SNAKE_CASE :       Optional[Any]=(64, 1_28, 1_28, 1_28, 1_28, 2_56, 2_56, 2_56, 2_56, 5_12, 5_12, 5_12, 5_12)							,       SCREAMING_SNAKE_CASE :       Any=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)							,       SCREAMING_SNAKE_CASE :       Optional[Any]=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)							,       SCREAMING_SNAKE_CASE :       Optional[int]=False							,       SCREAMING_SNAKE_CASE :       Union[str, Any]=1_28							,       SCREAMING_SNAKE_CASE :       Optional[Any]=16							,       SCREAMING_SNAKE_CASE :       Tuple=True							,       SCREAMING_SNAKE_CASE :       Optional[int]=0.0_5							,       SCREAMING_SNAKE_CASE :       Dict=10							,       SCREAMING_SNAKE_CASE :       Any=2							,       SCREAMING_SNAKE_CASE :       str=0.0							,       SCREAMING_SNAKE_CASE :       Optional[Any]=10							,       SCREAMING_SNAKE_CASE :       str=0							,       SCREAMING_SNAKE_CASE :       Optional[int]="mean"							,       SCREAMING_SNAKE_CASE :       Optional[int]=False							,       SCREAMING_SNAKE_CASE :       int=False							,       SCREAMING_SNAKE_CASE :       Optional[Any]=2_56							,       SCREAMING_SNAKE_CASE :       List[str]=0							,       SCREAMING_SNAKE_CASE :       Tuple=1							,       SCREAMING_SNAKE_CASE :       List[str]=2							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]							,       ):


      '''simple docstring'''






      super().__init__(**SCREAMING_SNAKE_CASE							,       pad_token_id=SCREAMING_SNAKE_CASE							,       bos_token_id=SCREAMING_SNAKE_CASE							,       eos_token_id=SCREAMING_SNAKE_CASE						)
      UpperCamelCase__      :       Dict	    =  hidden_size
      UpperCamelCase__      :       Optional[int]	    =  feat_extract_norm
      UpperCamelCase__      :       int	    =  feat_extract_activation
      UpperCamelCase__      :       Any	    =  list(SCREAMING_SNAKE_CASE						)
      UpperCamelCase__      :       Union[str, Any]	    =  list(SCREAMING_SNAKE_CASE						)
      UpperCamelCase__      :       Optional[Any]	    =  list(SCREAMING_SNAKE_CASE						)
      UpperCamelCase__      :       Optional[int]	    =  conv_bias
      UpperCamelCase__      :       str	    =  num_conv_pos_embeddings
      UpperCamelCase__      :       Optional[int]	    =  num_conv_pos_embedding_groups
      UpperCamelCase__      :       Optional[int]	    =  len(self.conv_dim						)
      UpperCamelCase__      :       List[Any]	    =  num_hidden_layers
      UpperCamelCase__      :       Any	    =  intermediate_size
      UpperCamelCase__      :       Dict	    =  squeeze_factor
      UpperCamelCase__      :       Union[str, Any]	    =  hidden_act
      UpperCamelCase__      :       Dict	    =  num_attention_heads
      UpperCamelCase__      :       Optional[int]	    =  hidden_dropout
      UpperCamelCase__      :       Optional[Any]	    =  attention_dropout
      UpperCamelCase__      :       int	    =  activation_dropout
      UpperCamelCase__      :       int	    =  feat_proj_dropout
      UpperCamelCase__      :       int	    =  final_dropout
      UpperCamelCase__      :       Any	    =  layerdrop
      UpperCamelCase__      :       List[str]	    =  layer_norm_eps
      UpperCamelCase__      :       Optional[Any]	    =  initializer_range
      UpperCamelCase__      :       List[str]	    =  vocab_size

      if (
          (len(self.conv_stride						) != self.num_feat_extract_layers)
          or (len(self.conv_kernel						) != self.num_feat_extract_layers)
          or (len(self.conv_dim						) != self.num_feat_extract_layers)
      ):
           raise ValueError(
               "Configuration for convolutional layers is incorrect."
               "It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,"
               F'but is `len(config.conv_dim) = {len(self.conv_dim						)}`, `len(config.conv_stride)'
               F'= {len(self.conv_stride						)}`, `len(config.conv_kernel) = {len(self.conv_kernel						)}`.'						)

      # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
      UpperCamelCase__      :       Dict	    =  apply_spec_augment
      UpperCamelCase__      :       List[str]	    =  mask_time_prob
      UpperCamelCase__      :       Any	    =  mask_time_length
      UpperCamelCase__      :       Dict	    =  mask_time_min_masks
      UpperCamelCase__      :       Dict	    =  mask_feature_prob
      UpperCamelCase__      :       Optional[int]	    =  mask_feature_length
      UpperCamelCase__      :       str	    =  mask_feature_min_masks

      # ctc loss
      UpperCamelCase__      :       int	    =  ctc_loss_reduction
      UpperCamelCase__      :       Union[str, Any]	    =  ctc_zero_infinity

      # sequence classification
      UpperCamelCase__      :       Dict	    =  use_weighted_layer_sum
      UpperCamelCase__      :       Optional[int]	    =  classifier_proj_size







 @property
 def  __lowercase (		self :       Optional[Any]						):


      '''simple docstring'''






      return functools.reduce(operator.mul							,       self.conv_stride							,       1						)







import argparse
import os
import re

import packaging.version


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







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







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Union[str, Any]:
     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 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase=False      )			->     Optional[int]:
     for pattern, fname in REPLACE_FILES.items():
          update_version_in_file(__lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )
     if not patch:
          update_version_in_examples(__lowerCAmelCase      )







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

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

     UpperCamelCase__      :       Dict	    =  start_index
     # Update the lines in the model list.
     while not lines[index].startswith(_end_prompt      ):
          if lines[index].startswith("1."      ):
               UpperCamelCase__      :       str	    =  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 		SCREAMING_SNAKE_CASE							( )			->     Tuple:
     with open(REPLACE_FILES["init"] ,   "r"      ) as f:
          UpperCamelCase__      :       str	    =  f.read()
     UpperCamelCase__      :       Dict	    =  REPLACE_PATTERNS["init"][0].search(__lowerCAmelCase      ).groups()[0]
     return packaging.version.parse(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase=False      )			->     Optional[int]:
     UpperCamelCase__      :       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:
          UpperCamelCase__      :       List[str]	    =  default_version.base_version
     elif patch:
          UpperCamelCase__      :       int	    =  f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
     else:
          UpperCamelCase__      :       Tuple	    =  f'{default_version.major}.{default_version.minor + 1}.0'

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

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