



"""simple docstring"""




import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
 from transformers import WhisperFeatureExtractor

if is_torch_available():
 import torch

_lowerCAmelCase							:   int				=				random.Random()

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Any		,    SCREAMING_SNAKE_CASE__      :		Dict=1.0		,    SCREAMING_SNAKE_CASE__      :		List[str]=None		,    SCREAMING_SNAKE_CASE__      :		int=None							)    ->  Any:





     '''simple docstring'''

     if rng is None:
          _UpperCAmelCase     :      Tuple														=       global_rng

     _UpperCAmelCase     :      int														=       []
     for batch_idx in range(shape[0]							):
          values.append([]							)
          for _ in range(shape[1]							):
               values[-1].append(rng.random() * scale							)

     return values






@require_torch
@require_torchaudio
class       UpperCAmelCase_    (							unittest.TestCase		):



      def __init__(	self	:      int	,      A	:      List[Any]	,      A	:      str=7	,      A	:      List[str]=4_0_0	,      A	:      Any=2_0_0_0	,      A	:      List[str]=1_0	,      A	:      Union[str, Any]=1_6_0	,      A	:      Optional[Any]=8	,      A	:      str=0.0	,      A	:      List[str]=4_0_0_0	,      A	:      str=False	,      A	:      str=True	,      ):
           _UpperCAmelCase     :      List[Any]														=       parent
           _UpperCAmelCase     :      int														=       batch_size
           _UpperCAmelCase     :      Optional[int]														=       min_seq_length
           _UpperCAmelCase     :      int														=       max_seq_length
           _UpperCAmelCase     :      Any														=       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
           _UpperCAmelCase     :      Optional[int]														=       padding_value
           _UpperCAmelCase     :      List[Any]														=       sampling_rate
           _UpperCAmelCase     :      Optional[Any]														=       return_attention_mask
           _UpperCAmelCase     :      Optional[Any]														=       do_normalize
           _UpperCAmelCase     :      Optional[Any]														=       feature_size
           _UpperCAmelCase     :      List[Any]														=       chunk_length
           _UpperCAmelCase     :      Optional[int]														=       hop_length



      def 		snake_case_   (	self	:      Any		):
           return {
               "feature_size": self.feature_size,
               "hop_length": self.hop_length,
               "chunk_length": self.chunk_length,
               "padding_value": self.padding_value,
               "sampling_rate": self.sampling_rate,
               "return_attention_mask": self.return_attention_mask,
               "do_normalize": self.do_normalize,
           }



      def 		snake_case_   (	self	:      List[str]	,      A	:      Tuple=False	,      A	:      int=False		):
           def _flatten(A	:      Any		):
                return list(itertools.chain(*A		)		)

           if equal_length:
                _UpperCAmelCase     :      Any														=       [floats_list((self.max_seq_length, self.feature_size)		) for _ in range(self.batch_size		)]
           else:
                # make sure that inputs increase in size
                _UpperCAmelCase     :      Optional[Any]														=       [
                    floats_list((x, self.feature_size)		)
                    for x in range(self.min_seq_length	,      self.max_seq_length	,      self.seq_length_diff		)
                ]
           if numpify:
                _UpperCAmelCase     :      str														=       [np.asarray(A		) for x in speech_inputs]
           return speech_inputs







@require_torch
@require_torchaudio
class       UpperCAmelCase_    (							_UpperCamelCase			,     unittest.TestCase		):
      __SCREAMING_SNAKE_CASE		:  Union[str, Any]						=					WhisperFeatureExtractor if is_speech_available() else None



      def 		snake_case_   (	self	:      Tuple		):
           _UpperCAmelCase     :      Tuple														=       WhisperFeatureExtractionTester(self		)



      def 		snake_case_   (	self	:      int		):
           _UpperCAmelCase     :      Union[str, Any]														=       self.feature_extraction_class(**self.feat_extract_dict		)

           with tempfile.TemporaryDirectory() as tmpdirname:
                _UpperCAmelCase     :      Optional[Any]														=       feat_extract_first.save_pretrained(A		)[0]
                check_json_file_has_correct_format(A		)
                _UpperCAmelCase     :      Optional[int]														=       self.feature_extraction_class.from_pretrained(A		)

           _UpperCAmelCase     :      Tuple														=       feat_extract_first.to_dict()
           _UpperCAmelCase     :      Dict														=       feat_extract_second.to_dict()
           _UpperCAmelCase     :      Any														=       feat_extract_first.mel_filters
           _UpperCAmelCase     :      Tuple														=       feat_extract_second.mel_filters
           self.assertTrue(np.allclose(A	,      A		)		)
           self.assertEqual(A	,      A		)



      def 		snake_case_   (	self	:      List[str]		):
           _UpperCAmelCase     :      Optional[Any]														=       self.feature_extraction_class(**self.feat_extract_dict		)

           with tempfile.TemporaryDirectory() as tmpdirname:
                _UpperCAmelCase     :      Union[str, Any]														=       os.path.join(A	,      "feat_extract.json"		)
                feat_extract_first.to_json_file(A		)
                _UpperCAmelCase     :      Tuple														=       self.feature_extraction_class.from_json_file(A		)

           _UpperCAmelCase     :      Any														=       feat_extract_first.to_dict()
           _UpperCAmelCase     :      Union[str, Any]														=       feat_extract_second.to_dict()
           _UpperCAmelCase     :      str														=       feat_extract_first.mel_filters
           _UpperCAmelCase     :      List[Any]														=       feat_extract_second.mel_filters
           self.assertTrue(np.allclose(A	,      A		)		)
           self.assertEqual(A	,      A		)



      def 		snake_case_   (	self	:      int		):
           # Tests that all call wrap to encode_plus and batch_encode_plus
           _UpperCAmelCase     :      Union[str, Any]														=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
           # create three inputs of length 800, 1000, and 1200
           _UpperCAmelCase     :      List[str]														=       [floats_list((1, x)		)[0] for x in range(8_0_0	,      1_4_0_0	,      2_0_0		)]
           _UpperCAmelCase     :      Dict														=       [np.asarray(A		) for speech_input in speech_inputs]

           # Test feature size
           _UpperCAmelCase     :      List[str]														=       feature_extractor(A	,      padding="max_length"	,      return_tensors="np"		).input_features
           self.assertTrue(input_features.ndim == 3		)
           self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames		)
           self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size		)

           # Test not batched input
           _UpperCAmelCase     :      Dict														=       feature_extractor(speech_inputs[0]	,      return_tensors="np"		).input_features
           _UpperCAmelCase     :      List[Any]														=       feature_extractor(np_speech_inputs[0]	,      return_tensors="np"		).input_features
           self.assertTrue(np.allclose(A	,      A	,      atol=1e-3		)		)

           # Test batched
           _UpperCAmelCase     :      Tuple														=       feature_extractor(A	,      return_tensors="np"		).input_features
           _UpperCAmelCase     :      List[Any]														=       feature_extractor(A	,      return_tensors="np"		).input_features
           for enc_seq_a, enc_seq_a in zip(A	,      A		):
                self.assertTrue(np.allclose(A	,      A	,      atol=1e-3		)		)

           # Test 2-D numpy arrays are batched.
           _UpperCAmelCase     :      Optional[Any]														=       [floats_list((1, x)		)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
           _UpperCAmelCase     :      int														=       np.asarray(A		)
           _UpperCAmelCase     :      List[Any]														=       feature_extractor(A	,      return_tensors="np"		).input_features
           _UpperCAmelCase     :      Optional[Any]														=       feature_extractor(A	,      return_tensors="np"		).input_features
           for enc_seq_a, enc_seq_a in zip(A	,      A		):
                self.assertTrue(np.allclose(A	,      A	,      atol=1e-3		)		)

           # Test truncation required
           _UpperCAmelCase     :      Tuple														=       [floats_list((1, x)		)[0] for x in range(2_0_0	,      (feature_extractor.n_samples + 5_0_0)	,      2_0_0		)]
           _UpperCAmelCase     :      str														=       [np.asarray(A		) for speech_input in speech_inputs]

           _UpperCAmelCase     :      List[str]														=       [x[: feature_extractor.n_samples] for x in speech_inputs]
           _UpperCAmelCase     :      Tuple														=       [np.asarray(A		) for speech_input in speech_inputs_truncated]

           _UpperCAmelCase     :      Any														=       feature_extractor(A	,      return_tensors="np"		).input_features
           _UpperCAmelCase     :      Optional[int]														=       feature_extractor(A	,      return_tensors="np"		).input_features
           for enc_seq_a, enc_seq_a in zip(A	,      A		):
                self.assertTrue(np.allclose(A	,      A	,      atol=1e-3		)		)



      def 		snake_case_   (	self	:      Any		):
           import torch

           _UpperCAmelCase     :      int														=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
           _UpperCAmelCase     :      Optional[int]														=       np.random.rand(1_0_0	,      3_2		).astype(np.floataa		)
           _UpperCAmelCase     :      Tuple														=       np_speech_inputs.tolist()

           for inputs in [py_speech_inputs, np_speech_inputs]:
                _UpperCAmelCase     :      Optional[int]														=       feature_extractor.pad([{"input_features": inputs}]	,      return_tensors="np"		)
                self.assertTrue(np_processed.input_features.dtype == np.floataa		)
                _UpperCAmelCase     :      str														=       feature_extractor.pad([{"input_features": inputs}]	,      return_tensors="pt"		)
                self.assertTrue(pt_processed.input_features.dtype == torch.floataa		)



      def 		snake_case_   (	self	:      Dict	,      A	:      Any		):
           _UpperCAmelCase     :      int														=       load_dataset("hf-internal-testing/librispeech_asr_dummy"	,      "clean"	,      split="validation"		)
           # automatic decoding with librispeech
           _UpperCAmelCase     :      Dict														=       ds.sort("id"		).select(range(A		)		)[:num_samples]["audio"]

           return [x["array"] for x in speech_samples]



      def 		snake_case_   (	self	:      List[Any]		):
           # fmt: off
           _UpperCAmelCase     :      int														=       torch.tensor(
               [
                   0.1_193, -0.0_946, -0.1_098, -0.0_196, 0.0_225, -0.0_690, -0.1_736, 0.0_951,
                   0.0_971, -0.0_817, -0.0_702, 0.0_162, 0.0_260, 0.0_017, -0.0_192, -0.1_678,
                   0.0_709, -0.1_867, -0.0_655, -0.0_274, -0.0_234, -0.1_884, -0.0_516, -0.0_554,
                   -0.0_274, -0.1_425, -0.1_423, 0.0_837, 0.0_377, -0.0_854
               ]		)
           # fmt: on

           _UpperCAmelCase     :      str														=       self._load_datasamples(1		)
           _UpperCAmelCase     :      Any														=       WhisperFeatureExtractor()
           _UpperCAmelCase     :      Tuple														=       feature_extractor(A	,      return_tensors="pt"		).input_features
           self.assertEqual(input_features.shape	,      (1, 8_0, 3_0_0_0)		)
           self.assertTrue(torch.allclose(input_features[0, 0, :3_0]	,      A	,      atol=1e-4		)		)



      def 		snake_case_   (	self	:      List[str]		):
           _UpperCAmelCase     :      Any														=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
           _UpperCAmelCase     :      str														=       self._load_datasamples(1		)[0]
           _UpperCAmelCase     :      List[Any]														=       ((audio - audio.min()) / (audio.max() - audio.min())) * 6_5_5_3_5  # Rescale to [0, 65535] to show issue
           _UpperCAmelCase     :      str														=       feat_extract.zero_mean_unit_var_norm([audio]	,      attention_mask=A		)[0]

           self.assertTrue(np.all(np.mean(A		) < 1e-3		)		)
           self.assertTrue(np.all(np.abs(np.var(A		) - 1		) < 1e-3		)		)





"""simple docstring"""




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


_lowerCAmelCase							:   Dict				=				"src/transformers"


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

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Optional[Any]							)    ->  int:





     '''simple docstring'''

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

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Any							)    ->  Dict:





     '''simple docstring'''

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

     _UpperCAmelCase     :      Optional[Any]														=       0
     while line_index < len(SCREAMING_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(SCREAMING_SNAKE_CASE__							):
          return None

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

     _UpperCAmelCase     :      Optional[int]														=       {"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     :      Optional[Any]														=       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     :      Dict														=       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     :      Union[str, Any]														=       []
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]							) <= 1 or lines[line_index].startswith(" " * 4							):
                    _UpperCAmelCase     :      Union[str, Any]														=       lines[line_index]
                    if _re_import_struct_add_one.search(SCREAMING_SNAKE_CASE__							) is not None:
                         objects.append(_re_import_struct_add_one.search(SCREAMING_SNAKE_CASE__							).groups()[0]							)
                    elif _re_import_struct_add_many.search(SCREAMING_SNAKE_CASE__							) is not None:
                         _UpperCAmelCase     :      int														=       _re_import_struct_add_many.search(SCREAMING_SNAKE_CASE__							).groups()[0].split(", "							)
                         _UpperCAmelCase     :      Dict														=       [obj[1:-1] for obj in imports if len(SCREAMING_SNAKE_CASE__							) > 0]
                         objects.extend(SCREAMING_SNAKE_CASE__							)
                    elif _re_between_brackets.search(SCREAMING_SNAKE_CASE__							) is not None:
                         _UpperCAmelCase     :      str														=       _re_between_brackets.search(SCREAMING_SNAKE_CASE__							).groups()[0].split(", "							)
                         _UpperCAmelCase     :      List[Any]														=       [obj[1:-1] for obj in imports if len(SCREAMING_SNAKE_CASE__							) > 0]
                         objects.extend(SCREAMING_SNAKE_CASE__							)
                    elif _re_quote_object.search(SCREAMING_SNAKE_CASE__							) is not None:
                         objects.append(_re_quote_object.search(SCREAMING_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     :      Optional[Any]														=       objects
          else:
               line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
     _UpperCAmelCase     :      int														=       []
     while (
         line_index < len(SCREAMING_SNAKE_CASE__							)
         and find_backend(lines[line_index]							) is None
         and not lines[line_index].startswith("else"							)
     ):
          _UpperCAmelCase     :      List[Any]														=       lines[line_index]
          _UpperCAmelCase     :      Optional[Any]														=       _re_import.search(SCREAMING_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     :      Union[str, Any]														=       {"none": objects}
     # Let's continue with backend-specific objects
     while line_index < len(SCREAMING_SNAKE_CASE__							):
          # If the line is an if is_backend_available, we grab all objects associated.
          _UpperCAmelCase     :      Any														=       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     :      List[str]														=       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     :      List[str]														=       []
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]							) <= 1 or lines[line_index].startswith(" " * 8							):
                    _UpperCAmelCase     :      Any														=       lines[line_index]
                    _UpperCAmelCase     :      Optional[int]														=       _re_import.search(SCREAMING_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     :      Union[str, Any]														=       objects
          else:
               line_index += 1

     return import_dict_objects, type_hint_objects

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Union[str, Any]		,    SCREAMING_SNAKE_CASE__      :		int							)    ->  Optional[int]:





     '''simple docstring'''

     def find_duplicates(SCREAMING_SNAKE_CASE__      :		int							):
          return [k for k, v in collections.Counter(SCREAMING_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     :      Any														=       []
     for key in import_dict_objects.keys():
          _UpperCAmelCase     :      Dict														=       find_duplicates(import_dict_objects[key]							)
          if duplicate_imports:
               errors.append(f'Duplicate _import_structure definitions for: {duplicate_imports}'							)
          _UpperCAmelCase     :      Tuple														=       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     :      List[Any]														=       "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 		__snake_case		( )    ->  Dict:





     '''simple docstring'''

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

def 		__snake_case		( )    ->  Optional[Any]:





     '''simple docstring'''

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


_lowerCAmelCase							:   Any				=				[
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
]

def 		__snake_case		( )    ->  Union[str, Any]:





     '''simple docstring'''

     _UpperCAmelCase     :      List[str]														=       importlib.util.spec_from_file_location(
         "transformers"		,    os.path.join(SCREAMING_SNAKE_CASE__		,    "__init__.py"							)		,    submodule_search_locations=[PATH_TO_TRANSFORMERS]		,    )
     _UpperCAmelCase     :      Optional[int]														=       spec.loader.load_module()

     _UpperCAmelCase     :      str														=       [
         module
         for module in get_transformers_submodules()
         if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
     ]
     if len(SCREAMING_SNAKE_CASE__							) > 0:
          _UpperCAmelCase     :      Optional[Any]														=       "\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()
