'''simple docstring'''





import collections
import importlib.util
import os
import re
from pathlib import Path


SCREAMING_SNAKE_CASE_:	Optional[int]    ='src/transformers'


# Matches is_xxx_available()
SCREAMING_SNAKE_CASE_:	Any    =re.compile(r'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
SCREAMING_SNAKE_CASE_:	Tuple    =re.compile(r'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
SCREAMING_SNAKE_CASE_:	List[str]    =re.compile(r'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
SCREAMING_SNAKE_CASE_:	Optional[Any]    =re.compile(r'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
SCREAMING_SNAKE_CASE_:	Tuple    =re.compile(r'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
SCREAMING_SNAKE_CASE_:	Tuple    =re.compile(r'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
SCREAMING_SNAKE_CASE_:	List[str]    =re.compile('^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
SCREAMING_SNAKE_CASE_:	str    =re.compile('^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
SCREAMING_SNAKE_CASE_:	List[Any]    =re.compile(r'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
SCREAMING_SNAKE_CASE_:	List[str]    =re.compile(r'^\s*try:')
# Catches a line with else:
SCREAMING_SNAKE_CASE_:	str    =re.compile(r'^\s*else:')





def       lowerCAmelCase_							(   snake_case_			:					Optional[int]     )       -> Union[str, Any]:


     '''simple docstring'''




     if _re_test_backend.search(snake_case_     ) is None:
          return None
     UpperCAmelCase_			       =  [b[0] for b in _re_backend.findall(snake_case_     )]
     backends.sort()
     return "_and_".join(snake_case_     )





def       lowerCAmelCase_							(   snake_case_			:					Union[str, Any]     )       -> int:


     '''simple docstring'''




     with open(snake_case_   ,       "r"   ,       encoding="utf-8"   ,       newline="\n"     ) as f:
          UpperCAmelCase_			       =  f.readlines()

     UpperCAmelCase_			       =  0
     while line_index < len(snake_case_     ) and not lines[line_index].startswith("_import_structure = {"     ):
          line_index += 1

     # If this is a traditional init, just return.
     if line_index >= len(snake_case_     ):
          return None

     # First grab the objects without a specific backend in _import_structure
     UpperCAmelCase_			       =  []
     while not lines[line_index].startswith("if TYPE_CHECKING"     ) and find_backend(lines[line_index]     ) is None:
          UpperCAmelCase_			       =  lines[line_index]
          # If we have everything on a single line, let's deal with it.
          if _re_one_line_import_struct.search(snake_case_     ):
               UpperCAmelCase_			       =  _re_one_line_import_struct.search(snake_case_     ).groups()[0]
               UpperCAmelCase_			       =  re.findall("\[([^\]]+)\]"   ,       snake_case_     )
               for imp in imports:
                    objects.extend([obj[1:-1] for obj in imp.split(", "     )]     )
               line_index += 1
               continue
          UpperCAmelCase_			       =  _re_import_struct_key_value.search(snake_case_     )
          if single_line_import_search is not None:
               UpperCAmelCase_			       =  [obj[1:-1] for obj in single_line_import_search.groups()[0].split(", "     ) if len(snake_case_     ) > 0]
               objects.extend(snake_case_     )
          elif line.startswith(" " * 8 + "\""     ):
               objects.append(line[9:-3]     )
          line_index += 1

     UpperCAmelCase_			       =  {"none": objects}
     # Let's continue with backend-specific objects in _import_structure
     while not lines[line_index].startswith("if TYPE_CHECKING"     ):
          # If the line is an if not is_backend_available, we grab all objects associated.
          UpperCAmelCase_			       =  find_backend(lines[line_index]     )
          # Check if the backend declaration is inside a try block:
          if _re_try.search(lines[line_index - 1]     ) is None:
               UpperCAmelCase_			       =  None

          if backend is not None:
               line_index += 1

               # Scroll until we hit the else block of try-except-else
               while _re_else.search(lines[line_index]     ) is None:
                    line_index += 1

               line_index += 1

               UpperCAmelCase_			       =  []
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]     ) <= 1 or lines[line_index].startswith(" " * 4     ):
                    UpperCAmelCase_			       =  lines[line_index]
                    if _re_import_struct_add_one.search(snake_case_     ) is not None:
                         objects.append(_re_import_struct_add_one.search(snake_case_     ).groups()[0]     )
                    elif _re_import_struct_add_many.search(snake_case_     ) is not None:
                         UpperCAmelCase_			       =  _re_import_struct_add_many.search(snake_case_     ).groups()[0].split(", "     )
                         UpperCAmelCase_			       =  [obj[1:-1] for obj in imports if len(snake_case_     ) > 0]
                         objects.extend(snake_case_     )
                    elif _re_between_brackets.search(snake_case_     ) is not None:
                         UpperCAmelCase_			       =  _re_between_brackets.search(snake_case_     ).groups()[0].split(", "     )
                         UpperCAmelCase_			       =  [obj[1:-1] for obj in imports if len(snake_case_     ) > 0]
                         objects.extend(snake_case_     )
                    elif _re_quote_object.search(snake_case_     ) is not None:
                         objects.append(_re_quote_object.search(snake_case_     ).groups()[0]     )
                    elif line.startswith(" " * 8 + "\""     ):
                         objects.append(line[9:-3]     )
                    elif line.startswith(" " * 12 + "\""     ):
                         objects.append(line[13:-3]     )
                    line_index += 1

               UpperCAmelCase_			       =  objects
          else:
               line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
     UpperCAmelCase_			       =  []
     while (
         line_index < len(snake_case_     )
         and find_backend(lines[line_index]     ) is None
         and not lines[line_index].startswith("else"     )
     ):
          UpperCAmelCase_			       =  lines[line_index]
          UpperCAmelCase_			       =  _re_import.search(snake_case_     )
          if single_line_import_search is not None:
               objects.extend(single_line_import_search.groups()[0].split(", "     )     )
          elif line.startswith(" " * 8     ):
               objects.append(line[8:-2]     )
          line_index += 1

     UpperCAmelCase_			       =  {"none": objects}
     # Let's continue with backend-specific objects
     while line_index < len(snake_case_     ):
          # If the line is an if is_backend_available, we grab all objects associated.
          UpperCAmelCase_			       =  find_backend(lines[line_index]     )
          # Check if the backend declaration is inside a try block:
          if _re_try.search(lines[line_index - 1]     ) is None:
               UpperCAmelCase_			       =  None

          if backend is not None:
               line_index += 1

               # Scroll until we hit the else block of try-except-else
               while _re_else.search(lines[line_index]     ) is None:
                    line_index += 1

               line_index += 1

               UpperCAmelCase_			       =  []
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]     ) <= 1 or lines[line_index].startswith(" " * 8     ):
                    UpperCAmelCase_			       =  lines[line_index]
                    UpperCAmelCase_			       =  _re_import.search(snake_case_     )
                    if single_line_import_search is not None:
                         objects.extend(single_line_import_search.groups()[0].split(", "     )     )
                    elif line.startswith(" " * 12     ):
                         objects.append(line[12:-2]     )
                    line_index += 1

               UpperCAmelCase_			       =  objects
          else:
               line_index += 1

     return import_dict_objects, type_hint_objects





def       lowerCAmelCase_							(   snake_case_			:					List[str]   ,       snake_case_			:					Union[str, Any]     )       -> Dict:


     '''simple docstring'''




     def find_duplicates(snake_case_			:					int     ):
          return [k for k, v in collections.Counter(snake_case_     ).items() if v > 1]

     if list(import_dict_objects.keys()     ) != list(type_hint_objects.keys()     ):
          return ["Both sides of the init do not have the same backends!"]

     UpperCAmelCase_			       =  []
     for key in import_dict_objects.keys():
          UpperCAmelCase_			       =  find_duplicates(import_dict_objects[key]     )
          if duplicate_imports:
               errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""     )
          UpperCAmelCase_			       =  find_duplicates(type_hint_objects[key]     )
          if duplicate_type_hints:
               errors.append(f"""Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}"""     )

          if sorted(set(import_dict_objects[key]     )     ) != sorted(set(type_hint_objects[key]     )     ):
               UpperCAmelCase_			       =  "base imports" if key == "none" else f"""{key} backend"""
               errors.append(f"""Differences for {name}:"""     )
               for a in type_hint_objects[key]:
                    if a not in import_dict_objects[key]:
                         errors.append(f"""  {a} in TYPE_HINT but not in _import_structure."""     )
               for a in import_dict_objects[key]:
                    if a not in type_hint_objects[key]:
                         errors.append(f"""  {a} in _import_structure but not in TYPE_HINT."""     )
     return errors





def       lowerCAmelCase_							(   )       -> Dict:


     '''simple docstring'''




     UpperCAmelCase_			       =  []
     for root, _, files in os.walk(snake_case_     ):
          if "__init__.py" in files:
               UpperCAmelCase_			       =  os.path.join(snake_case_   ,       "__init__.py"     )
               UpperCAmelCase_			       =  parse_init(snake_case_     )
               if objects is not None:
                    UpperCAmelCase_			       =  analyze_results(*snake_case_     )
                    if len(snake_case_     ) > 0:
                         UpperCAmelCase_			       =  f"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
                         failures.append("\n".join(snake_case_     )     )
     if len(snake_case_     ) > 0:
          raise ValueError("\n\n".join(snake_case_     )     )





def       lowerCAmelCase_							(   )       -> Optional[int]:


     '''simple docstring'''




     UpperCAmelCase_			       =  []
     for path, directories, files in os.walk(snake_case_     ):
          for folder in directories:
               # Ignore private modules
               if folder.startswith("_"     ):
                    directories.remove(snake_case_     )
                    continue
               # Ignore leftovers from branches (empty folders apart from pycache)
               if len(list((Path(snake_case_     ) / folder).glob("*.py"     )     )     ) == 0:
                    continue
               UpperCAmelCase_			       =  str((Path(snake_case_     ) / folder).relative_to(snake_case_     )     )
               UpperCAmelCase_			       =  short_path.replace(os.path.sep   ,       "."     )
               submodules.append(snake_case_     )
          for fname in files:
               if fname == "__init__.py":
                    continue
               UpperCAmelCase_			       =  str((Path(snake_case_     ) / fname).relative_to(snake_case_     )     )
               UpperCAmelCase_			       =  short_path.replace(".py"   ,       ""     ).replace(os.path.sep   ,       "."     )
               if len(submodule.split("."     )     ) == 1:
                    submodules.append(snake_case_     )
     return submodules


SCREAMING_SNAKE_CASE_:	Tuple    =[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]





def       lowerCAmelCase_							(   )       -> Any:


     '''simple docstring'''




     UpperCAmelCase_			       =  importlib.util.spec_from_file_location(
         "transformers"   ,       os.path.join(snake_case_   ,       "__init__.py"     )   ,       submodule_search_locations=[PATH_TO_TRANSFORMERS]   ,       )
     UpperCAmelCase_			       =  spec.loader.load_module()

     UpperCAmelCase_			       =  [
         module
         for module in get_transformers_submodules()
         if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
     ]
     if len(snake_case_     ) > 0:
          UpperCAmelCase_			       =  "\n".join(f"""- {module}""" for module in module_not_registered     )
          raise ValueError(
              "The following submodules are not properly registered in the main init of Transformers:\n"
              f"""{list_of_modules}\n"""
              "Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value."     )


if __name__ == "__main__":
    check_all_inits()
    check_submodules()









import functools
import operator

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


_lowerCAmelCase	:   List[str]    =   logging.get_logger(__name__)

_lowerCAmelCase	:   Tuple    =   {
    "microsoft/wavlm-base": "https://huggingface.co/microsoft/wavlm-base/resolve/main/config.json",
    # See all WavLM models at https://huggingface.co/models?filter=wavlm
}


class 	__snake_case   ( SCREAMING_SNAKE_CASE ):
		SCREAMING_SNAKE_CASE__								=	'wavlm'
		def __init__(							self    ,a_=32    ,a_=768    ,a_=12    ,a_=12    ,a_=3072    ,a_="gelu"    ,a_=0.1    ,a_=0.1    ,a_=0.1    ,a_=0.0    ,a_=0.1    ,a_=0.1    ,a_=0.02    ,a_=1e-5    ,a_="group"    ,a_="gelu"    ,a_=(512, 512, 512, 512, 512, 512, 512)    ,a_=(5, 2, 2, 2, 2, 2, 2)    ,a_=(10, 3, 3, 3, 3, 2, 2)    ,a_=False    ,a_=128    ,a_=16    ,a_=320    ,a_=800    ,a_=False    ,a_=True    ,a_=0.05    ,a_=10    ,a_=2    ,a_=0.0    ,a_=10    ,a_=320    ,a_=2    ,a_=0.1    ,a_=100    ,a_=256    ,a_=256    ,a_=0.1    ,a_="mean"    ,a_=False    ,a_=False    ,a_=256    ,a_=(512, 512, 512, 512, 1500)    ,a_=(5, 3, 3, 1, 1)    ,a_=(1, 2, 3, 1, 1)    ,a_=512    ,a_=80    ,a_=0    ,a_=1    ,a_=2    ,a_=False    ,a_=3    ,a_=2    ,a_=3    ,a_=None    ,**a_    ,):







						"""simple docstring"""
						super().__init__(**a_    ,pad_token_id=a_    ,bos_token_id=a_    ,eos_token_id=a_						)
						lowerCAmelCase__		  =  hidden_size
						lowerCAmelCase__		  =  feat_extract_norm
						lowerCAmelCase__		  =  feat_extract_activation
						lowerCAmelCase__		  =  list(a_						)
						lowerCAmelCase__		  =  list(a_						)
						lowerCAmelCase__		  =  list(a_						)
						lowerCAmelCase__		  =  conv_bias
						lowerCAmelCase__		  =  num_buckets
						lowerCAmelCase__		  =  max_bucket_distance
						lowerCAmelCase__		  =  num_conv_pos_embeddings
						lowerCAmelCase__		  =  num_conv_pos_embedding_groups
						lowerCAmelCase__		  =  len(self.conv_dim						)
						lowerCAmelCase__		  =  num_hidden_layers
						lowerCAmelCase__		  =  intermediate_size
						lowerCAmelCase__		  =  hidden_act
						lowerCAmelCase__		  =  num_attention_heads
						lowerCAmelCase__		  =  hidden_dropout
						lowerCAmelCase__		  =  attention_dropout
						lowerCAmelCase__		  =  activation_dropout
						lowerCAmelCase__		  =  feat_proj_dropout
						lowerCAmelCase__		  =  final_dropout
						lowerCAmelCase__		  =  layerdrop
						lowerCAmelCase__		  =  layer_norm_eps
						lowerCAmelCase__		  =  initializer_range
						lowerCAmelCase__		  =  num_ctc_classes
						lowerCAmelCase__		  =  vocab_size
						lowerCAmelCase__		  =  do_stable_layer_norm
						lowerCAmelCase__		  =  use_weighted_layer_sum
						lowerCAmelCase__		  =  classifier_proj_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)`, but is `len(config.conv_dim) ='
										    f' {len(self.conv_dim						)}`, `len(config.conv_stride) = {len(self.conv_stride						)}`,'
										    f' `len(config.conv_kernel) = {len(self.conv_kernel						)}`.'						)

						# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
						lowerCAmelCase__		  =  apply_spec_augment
						lowerCAmelCase__		  =  mask_time_prob
						lowerCAmelCase__		  =  mask_time_length
						lowerCAmelCase__		  =  mask_time_min_masks
						lowerCAmelCase__		  =  mask_feature_prob
						lowerCAmelCase__		  =  mask_feature_length

						# parameters for pretraining with codevector quantized representations
						lowerCAmelCase__		  =  num_codevectors_per_group
						lowerCAmelCase__		  =  num_codevector_groups
						lowerCAmelCase__		  =  contrastive_logits_temperature
						lowerCAmelCase__		  =  num_negatives
						lowerCAmelCase__		  =  codevector_dim
						lowerCAmelCase__		  =  proj_codevector_dim
						lowerCAmelCase__		  =  diversity_loss_weight

						# ctc loss
						lowerCAmelCase__		  =  ctc_loss_reduction
						lowerCAmelCase__		  =  ctc_zero_infinity

						# adapter
						lowerCAmelCase__		  =  add_adapter
						lowerCAmelCase__		  =  adapter_kernel_size
						lowerCAmelCase__		  =  adapter_stride
						lowerCAmelCase__		  =  num_adapter_layers
						lowerCAmelCase__		  =  output_hidden_size or hidden_size

						# SequenceClassification-specific parameter. Feel free to ignore for other classes.
						lowerCAmelCase__		  =  classifier_proj_size

						# XVector-specific parameters. Feel free to ignore for other classes.
						lowerCAmelCase__		  =  list(a_						)
						lowerCAmelCase__		  =  list(a_						)
						lowerCAmelCase__		  =  list(a_						)
						lowerCAmelCase__		  =  xvector_output_dim



		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







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