



import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:List[Any]				)  ->     Tuple:
   _A      =       int(_snake_case				)
   _A  ,    _A  ,    _A      =       t // 3_600, (t // 60) % 60, t % 60
   return F'''{h}:{m:02d}:{s:02d}''' if h != 0 else F'''{m:02d}:{s:02d}'''

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:int	,   _snake_case	:Optional[Any]	,   _snake_case	:str	,   _snake_case	:int	,   _snake_case	:Optional[Any]=300				)  ->     Union[str, Any]:
   # docstyle-ignore
   return F'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:int				)  ->     Dict:
   _A      =       '''<table border="1" class="dataframe">\n'''
   html_code += """  <thead>\n <tr style="text-align: left;">\n"""
   for i in items[0]:
      html_code += F'''      <th>{i}</th>\n'''
   html_code += "    </tr>\n  </thead>\n  <tbody>\n"
   for line in items[1:]:
      html_code += "    <tr>\n"
      for elt in line:
         _A      =       F'''{elt:.6f}''' if isinstance(_snake_case	,   _snake_case				) else str(_snake_case				)
         html_code += F'''      <td>{elt}</td>\n'''
      html_code += "    </tr>\n"
   html_code += "  </tbody>\n</table><p>"
   return html_code


class 	lowerCamelCase__	:



 """simple docstring"""

 a__					: str =  5
 a__					: Optional[Any] =  0.2

 def __init__(    self					:					int			,						__lowerCAmelCase					:					int			,						__lowerCAmelCase					:					Optional[str] = None			,						__lowerCAmelCase					:					bool = True			,						__lowerCAmelCase					:					Optional["NotebookTrainingTracker"] = None			,						__lowerCAmelCase					:					int = 3_00			,						)   ->	Optional[int]:
    _A      =       total
    _A      =       '''''' if prefix is None else prefix
    _A      =       leave
    _A      =       parent
    _A      =       width
    _A      =       None
    _A      =       None
    _A      =       None

 def     snake_case_      (    self					:					int			,						__lowerCAmelCase					:					int			,						__lowerCAmelCase					:					bool = False			,						__lowerCAmelCase					:					str = None      )   ->	str:
    _A      =       value
    if comment is not None:
       _A      =       comment
    if self.last_value is None:
       _A      =       _A      =       time.time()
       _A      =       _A      =       value
       _A      =       _A      =       None
       _A      =       self.warmup
       _A      =       1
       self.update_bar(__lowerCAmelCase      )
    elif value <= self.last_value and not force_update:
       return
    elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for			,						self.total      ):
       if self.first_calls > 0:
          self.first_calls -= 1
       _A      =       time.time()
       _A      =       current_time - self.start_time
       # We could have value = self.start_value if the update is called twixe with the same start value.
       if value > self.start_value:
          _A      =       self.elapsed_time / (value - self.start_value)
       else:
          _A      =       None
       if value >= self.total:
          _A      =       self.total
          _A      =       None
          if not self.leave:
             self.close()
       elif self.average_time_per_item is not None:
          _A      =       self.average_time_per_item * (self.total - value)
       self.update_bar(__lowerCAmelCase      )
       _A      =       value
       _A      =       current_time
       if self.average_time_per_item is None:
          _A      =       1
       else:
          _A      =       max(int(self.update_every / self.average_time_per_item      )			,						1      )

 def     snake_case_      (    self					:					List[str]			,						__lowerCAmelCase					:					List[Any]			,						__lowerCAmelCase					:					Any=None      )   ->	List[Any]:
    _A      =       ''' ''' * (len(str(self.total      )      ) - len(str(__lowerCAmelCase      )      )) + str(__lowerCAmelCase      )
    if self.elapsed_time is None:
       _A      =       f'''[{spaced_value}/{self.total} : < :'''
    elif self.predicted_remaining is None:
       _A      =       f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time      )}'''
    else:
       _A      =       (
           f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time      )} <'''
           f''' {format_time(self.predicted_remaining      )}'''
       )
       self.label += f''', {1/self.average_time_per_item:.2f} it/s'''
    self.label += "]" if self.comment is None or len(self.comment      ) == 0 else f''', {self.comment}]'''
    self.display()

 def     snake_case_      (    self					:					List[Any]      )   ->	Union[str, Any]:
    _A      =       html_progress_bar(self.value			,						self.total			,						self.prefix			,						self.label			,						self.width      )
    if self.parent is not None:
       # If this is a child bar, the parent will take care of the display.
       self.parent.display()
       return
    if self.output is None:
       _A      =       disp.display(disp.HTML(self.html_code      )			,						display_id=__lowerCAmelCase      )
    else:
       self.output.update(disp.HTML(self.html_code      )      )

 def     snake_case_      (    self					:					List[Any]      )   ->	Dict:
    if self.parent is None and self.output is not None:
       self.output.update(disp.HTML(''''''      )      )


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 def __init__(    self					:					Optional[Any]			,						__lowerCAmelCase					:					Dict			,						__lowerCAmelCase					:					List[Any]=None      )   ->	Optional[int]:
    super().__init__(__lowerCAmelCase      )
    _A      =       None if column_names is None else [column_names]
    _A      =       None

 def     snake_case_      (    self					:					str      )   ->	int:
    _A      =       html_progress_bar(self.value			,						self.total			,						self.prefix			,						self.label			,						self.width      )
    if self.inner_table is not None:
       self.html_code += text_to_html_table(self.inner_table      )
    if self.child_bar is not None:
       self.html_code += self.child_bar.html_code
    if self.output is None:
       _A      =       disp.display(disp.HTML(self.html_code      )			,						display_id=__lowerCAmelCase      )
    else:
       self.output.update(disp.HTML(self.html_code      )      )

 def     snake_case_      (    self					:					Any			,						__lowerCAmelCase					:					Dict      )   ->	int:
    if self.inner_table is None:
       _A      =       [list(values.keys()      ), list(values.values()      )]
    else:
       _A      =       self.inner_table[0]
       if len(self.inner_table      ) == 1:
          # We give a chance to update the column names at the first iteration
          for key in values.keys():
             if key not in columns:
                columns.append(__lowerCAmelCase      )
          _A      =       columns
       self.inner_table.append([values[c] for c in columns]      )

 def     snake_case_      (    self					:					Tuple			,						__lowerCAmelCase					:					int			,						__lowerCAmelCase					:					Optional[int]=None			,						__lowerCAmelCase					:					List[Any]=3_00      )   ->	Optional[int]:
    _A      =       NotebookProgressBar(__lowerCAmelCase			,						prefix=__lowerCAmelCase			,						parent=self			,						width=__lowerCAmelCase      )
    return self.child_bar

 def     snake_case_      (    self					:					Dict      )   ->	int:
    _A      =       None
    self.display()


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 def __init__(    self					:					Dict      )   ->	Tuple:
    _A      =       None
    _A      =       None
    _A      =       False

 def     snake_case_      (    self					:					Any			,						__lowerCAmelCase					:					List[Any]			,						__lowerCAmelCase					:					Union[str, Any]			,						__lowerCAmelCase					:					str			,						**__lowerCAmelCase					:					Dict      )   ->	Tuple:
    _A      =       '''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
    _A      =       0
    _A      =       0
    _A      =       [self.first_column] + ['''Training Loss''']
    if args.evaluation_strategy != IntervalStrategy.NO:
       column_names.append('''Validation Loss'''      )
    _A      =       NotebookTrainingTracker(state.max_steps			,						__lowerCAmelCase      )

 def     snake_case_      (    self					:					Optional[int]			,						__lowerCAmelCase					:					str			,						__lowerCAmelCase					:					int			,						__lowerCAmelCase					:					Dict			,						**__lowerCAmelCase					:					Union[str, Any]      )   ->	Tuple:
    _A      =       int(state.epoch      ) if int(state.epoch      ) == state.epoch else f'''{state.epoch:.2f}'''
    self.training_tracker.update(
        state.global_step + 1			,						comment=f'''Epoch {epoch}/{state.num_train_epochs}'''			,						force_update=self._force_next_update			,						)
    _A      =       False

 def     snake_case_      (    self					:					Any			,						__lowerCAmelCase					:					str			,						__lowerCAmelCase					:					Optional[int]			,						__lowerCAmelCase					:					Any			,						__lowerCAmelCase					:					List[Any]=None			,						**__lowerCAmelCase					:					int      )   ->	Union[str, Any]:
    if not has_length(__lowerCAmelCase      ):
       return
    if self.prediction_bar is None:
       if self.training_tracker is not None:
          _A      =       self.training_tracker.add_child(len(__lowerCAmelCase      )      )
       else:
          _A      =       NotebookProgressBar(len(__lowerCAmelCase      )      )
       self.prediction_bar.update(1      )
    else:
       self.prediction_bar.update(self.prediction_bar.value + 1      )

 def     snake_case_      (    self					:					List[Any]			,						__lowerCAmelCase					:					Optional[Any]			,						__lowerCAmelCase					:					List[Any]			,						__lowerCAmelCase					:					str			,						**__lowerCAmelCase					:					Any      )   ->	Optional[int]:
    if self.prediction_bar is not None:
       self.prediction_bar.close()
    _A      =       None

 def     snake_case_      (    self					:					str			,						__lowerCAmelCase					:					Union[str, Any]			,						__lowerCAmelCase					:					Any			,						__lowerCAmelCase					:					Dict			,						__lowerCAmelCase					:					int=None			,						**__lowerCAmelCase					:					Optional[int]      )   ->	List[Any]:
    # Only for when there is no evaluation
    if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
       _A      =       {'''Training Loss''': logs['''loss''']}
       # First column is necessarily Step sine we're not in epoch eval strategy
       _A      =       state.global_step
       self.training_tracker.write_line(__lowerCAmelCase      )

 def     snake_case_      (    self					:					Union[str, Any]			,						__lowerCAmelCase					:					str			,						__lowerCAmelCase					:					Any			,						__lowerCAmelCase					:					List[Any]			,						__lowerCAmelCase					:					List[str]=None			,						**__lowerCAmelCase					:					Dict      )   ->	str:
    if self.training_tracker is not None:
       _A      =       {'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
       for log in reversed(state.log_history      ):
          if "loss" in log:
             _A      =       log['''loss''']
             break

       if self.first_column == "Epoch":
          _A      =       int(state.epoch      )
       else:
          _A      =       state.global_step
       _A      =       '''eval'''
       for k in metrics:
          if k.endswith('''_loss'''      ):
             _A      =       re.sub(R'''\_loss$'''			,						''''''			,						__lowerCAmelCase      )
       _A      =       metrics.pop('''total_flos'''			,						__lowerCAmelCase      )
       _A      =       metrics.pop('''epoch'''			,						__lowerCAmelCase      )
       _A      =       metrics.pop(f'''{metric_key_prefix}_runtime'''			,						__lowerCAmelCase      )
       _A      =       metrics.pop(f'''{metric_key_prefix}_samples_per_second'''			,						__lowerCAmelCase      )
       _A      =       metrics.pop(f'''{metric_key_prefix}_steps_per_second'''			,						__lowerCAmelCase      )
       _A      =       metrics.pop(f'''{metric_key_prefix}_jit_compilation_time'''			,						__lowerCAmelCase      )
       for k, v in metrics.items():
          if k == f'''{metric_key_prefix}_loss''':
             _A      =       v
          else:
             _A      =       k.split('''_'''      )
             _A      =       ''' '''.join([part.capitalize() for part in splits[1:]]      )
             _A      =       v
       self.training_tracker.write_line(__lowerCAmelCase      )
       self.training_tracker.remove_child()
       _A      =       None
       # Evaluation takes a long time so we should force the next update.
       _A      =       True

 def     snake_case_      (    self					:					Tuple			,						__lowerCAmelCase					:					str			,						__lowerCAmelCase					:					Optional[Any]			,						__lowerCAmelCase					:					Optional[int]			,						**__lowerCAmelCase					:					Dict      )   ->	Tuple:
    self.training_tracker.update(
        state.global_step			,						comment=f'''Epoch {int(state.epoch      )}/{state.num_train_epochs}'''			,						force_update=__lowerCAmelCase      )
    _A      =       None








import collections
import os
import re
from pathlib import Path


UpperCAmelCase_		 =					"""src/transformers"""


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

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:Optional[int]				)  ->     Any:
   if _re_test_backend.search(_snake_case				) is None:
      return None
   _A      =       [b[0] for b in _re_backend.findall(_snake_case				)]
   backends.sort()
   return "_and_".join(_snake_case				)

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:Any				)  ->     Any:
   with open(_snake_case	,   '''r'''	,   encoding='''utf-8'''	,   newline='''\n'''				) as f:
      _A      =       f.readlines()

   _A      =       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
   _A      =       []
   while not lines[line_index].startswith('''if TYPE_CHECKING'''				) and find_backend(lines[line_index]				) is None:
      _A      =       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				):
         _A      =       _re_one_line_import_struct.search(_snake_case				).groups()[0]
         _A      =       re.findall(r'''\[([^\]]+)\]'''	,   _snake_case				)
         for imp in imports:
            objects.extend([obj[1:-1] for obj in imp.split(''', '''				)]				)
         line_index += 1
         continue
      _A      =       _re_import_struct_key_value.search(_snake_case				)
      if single_line_import_search is not None:
         _A      =       [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

   _A      =       {'''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.
      _A      =       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:
         _A      =       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

         _A      =       []
         # Until we unindent, add backend objects to the list
         while len(lines[line_index]				) <= 1 or lines[line_index].startswith(''' ''' * 4				):
            _A      =       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:
               _A      =       _re_import_struct_add_many.search(_snake_case				).groups()[0].split(''', '''				)
               _A      =       [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:
               _A      =       _re_between_brackets.search(_snake_case				).groups()[0].split(''', '''				)
               _A      =       [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

         _A      =       objects
      else:
         line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
   _A      =       []
   while (
       line_index < len(_snake_case				)
       and find_backend(lines[line_index]				) is None
       and not lines[line_index].startswith('''else'''				)
   ):
      _A      =       lines[line_index]
      _A      =       _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

   _A      =       {'''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.
      _A      =       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:
         _A      =       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

         _A      =       []
         # Until we unindent, add backend objects to the list
         while len(lines[line_index]				) <= 1 or lines[line_index].startswith(''' ''' * 8				):
            _A      =       lines[line_index]
            _A      =       _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

         _A      =       objects
      else:
         line_index += 1

   return import_dict_objects, type_hint_objects

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:List[str]	,   _snake_case	:Dict				)  ->     Any:

   def find_duplicates(_snake_case	:Any				):
      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!"]

   _A      =       []
   for key in import_dict_objects.keys():
      _A      =       find_duplicates(import_dict_objects[key]				)
      if duplicate_imports:
         errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''				)
      _A      =       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]				)				):
         _A      =       '''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 	SCREAMING_SNAKE_CASE_							(	)  ->     int:
   _A      =       []
   for root, _, files in os.walk(_snake_case				):
      if "__init__.py" in files:
         _A      =       os.path.join(_snake_case	,   '''__init__.py'''				)
         _A      =       parse_init(_snake_case				)
         if objects is not None:
            _A      =       analyze_results(*_snake_case				)
            if len(_snake_case				) > 0:
               _A      =       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 	SCREAMING_SNAKE_CASE_							(	)  ->     Optional[int]:
   _A      =       []
   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
         _A      =       str((Path(_snake_case				) / folder).relative_to(_snake_case				)				)
         _A      =       short_path.replace(os.path.sep	,   '''.'''				)
         submodules.append(_snake_case				)
      for fname in files:
         if fname == "__init__.py":
            continue
         _A      =       str((Path(_snake_case				) / fname).relative_to(_snake_case				)				)
         _A      =       short_path.replace('''.py'''	,   ''''''				).replace(os.path.sep	,   '''.'''				)
         if len(submodule.split('''.'''				)				) == 1:
            submodules.append(_snake_case				)
   return submodules


UpperCAmelCase_		 =					[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]

def 	SCREAMING_SNAKE_CASE_							(	)  ->     List[str]:
   # This is to make sure the transformers module imported is the one in the repo.
   from transformers.utils import direct_transformers_import

   _A      =       direct_transformers_import(_snake_case				)

   _A      =       set(transformers._import_structure.keys()				)
   # This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
   # some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
   # (potentiall re-) add them.
   with open(os.path.join(_snake_case	,   '''__init__.py'''				)	,   '''r'''				) as f:
      _A      =       f.read()
   import_structure_keys.update(set(re.findall(r'''import_structure\[\"([^\"]*)\"\]'''	,   _snake_case				)				)				)

   _A      =       [
       module
       for module in get_transformers_submodules()
       if module not in IGNORE_SUBMODULES and module not in import_structure_keys
   ]

   if len(_snake_case				) > 0:
      _A      =       '''\n'''.join(F'''- {module}''' for module in module_not_registered				)
      raise ValueError(
          '''The following submodules are not properly registed 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()



