



from abc import ABC, abstractmethod
from typing import List, Optional


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 def __init__(    self					:					Dict      )   ->	Tuple:
    # test for the above condition
    self.test()

 def     snake_case_      (    self					:					List[str]      )   ->	Dict:
    _A      =       0
    _A      =       False
    while not completed:
       if counter == 1:
          self.reset()
       _A      =       self.advance()
       if not self.does_advance(__lowerCAmelCase      ):
          raise Exception(
              '''Custom Constraint is not defined correctly. self.does_advance(self.advance()) must be true.'''      )

       _A  ,    _A  ,    _A      =       self.update(__lowerCAmelCase      )
       counter += 1

       if counter > 1_00_00:
          raise Exception('''update() does not fulfill the constraint.'''      )

    if self.remaining() != 0:
       raise Exception('''Custom Constraint is not defined correctly.'''      )

 @abstractmethod
 def     snake_case_      (    self					:					Dict      )   ->	str:
    raise NotImplementedError(
        f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''      )

 @abstractmethod
 def     snake_case_      (    self					:					List[Any]			,						__lowerCAmelCase					:					int      )   ->	Any:
    raise NotImplementedError(
        f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''      )

 @abstractmethod
 def     snake_case_      (    self					:					Union[str, Any]			,						__lowerCAmelCase					:					int      )   ->	Tuple:
    raise NotImplementedError(
        f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''      )

 @abstractmethod
 def     snake_case_      (    self					:					List[str]      )   ->	Optional[int]:
    raise NotImplementedError(
        f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''      )

 @abstractmethod
 def     snake_case_      (    self					:					List[Any]      )   ->	int:
    raise NotImplementedError(
        f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''      )

 @abstractmethod
 def     snake_case_      (    self					:					Tuple			,						__lowerCAmelCase					:					Union[str, Any]=False      )   ->	Optional[Any]:
    raise NotImplementedError(
        f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''      )


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 def __init__(    self					:					List[Any]			,						__lowerCAmelCase					:					List[int]      )   ->	Any:
    super(__lowerCAmelCase			,						self      ).__init__()

    if not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ) or len(__lowerCAmelCase      ) == 0:
       raise ValueError(f'''`token_ids` has to be a non-empty list, but is {token_ids}.'''      )
    if any((not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ) or token_id < 0) for token_id in token_ids      ):
       raise ValueError(f'''Each list in `token_ids` has to be a list of positive integers, but is {token_ids}.'''      )

    _A      =       token_ids

    _A      =       len(self.token_ids      )
    _A      =       -1  # the index of the currently fulfilled step
    _A      =       False

 def     snake_case_      (    self					:					Optional[int]      )   ->	str:
    if self.completed:
       return None
    return self.token_ids[self.fulfilled_idx + 1]

 def     snake_case_      (    self					:					Optional[Any]			,						__lowerCAmelCase					:					int      )   ->	str:
    if not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
       raise ValueError(f'''`token_id` has to be an `int`, but is {token_id} of type {type(__lowerCAmelCase      )}'''      )

    if self.completed:
       return False

    return token_id == self.token_ids[self.fulfilled_idx + 1]

 def     snake_case_      (    self					:					Dict			,						__lowerCAmelCase					:					int      )   ->	str:
    if not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
       raise ValueError(f'''`token_id` has to be an `int`, but is {token_id} of type {type(__lowerCAmelCase      )}'''      )

    _A      =       False
    _A      =       False
    _A      =       False

    if self.does_advance(__lowerCAmelCase      ):
       self.fulfilled_idx += 1
       _A      =       True
       if self.fulfilled_idx == (self.seqlen - 1):
          _A      =       True
       _A      =       completed
    else:
       # failed to make progress.
       _A      =       True
       self.reset()
    return stepped, completed, reset

 def     snake_case_      (    self					:					Union[str, Any]      )   ->	int:
    _A      =       False
    _A      =       0

 def     snake_case_      (    self					:					Union[str, Any]      )   ->	Any:
    return self.seqlen - (self.fulfilled_idx + 1)

 def     snake_case_      (    self					:					Optional[int]			,						__lowerCAmelCase					:					Dict=False      )   ->	str:
    _A      =       PhrasalConstraint(self.token_ids      )

    if stateful:
       _A      =       self.seqlen
       _A      =       self.fulfilled_idx
       _A      =       self.completed

    return new_constraint


class 	lowerCamelCase__	:



 """simple docstring"""

 def __init__(    self					:					Union[str, Any]			,						__lowerCAmelCase					:					List[List[int]]			,						__lowerCAmelCase					:					Optional[Any]=True      )   ->	Any:
    _A      =       max([len(__lowerCAmelCase      ) for one in nested_token_ids]      )

    _A      =       {}
    for token_ids in nested_token_ids:
       _A      =       root
       for tidx, token_id in enumerate(__lowerCAmelCase      ):
          if token_id not in level:
             _A      =       {}

          _A      =       level[token_id]

    if no_subsets and self.has_subsets(__lowerCAmelCase			,						__lowerCAmelCase      ):
       raise ValueError(
           '''Each list in `nested_token_ids` can\'t be a complete subset of another list, but is'''
           f''' {nested_token_ids}.'''      )

    _A      =       root

 def     snake_case_      (    self					:					Dict			,						__lowerCAmelCase					:					str      )   ->	List[str]:
    _A      =       self.trie

    for current_token in current_seq:
       _A      =       start[current_token]

    _A      =       list(start.keys()      )

    return next_tokens

 def     snake_case_      (    self					:					List[str]			,						__lowerCAmelCase					:					str      )   ->	int:
    _A      =       self.next_tokens(__lowerCAmelCase      )

    return len(__lowerCAmelCase      ) == 0

 def     snake_case_      (    self					:					List[str]			,						__lowerCAmelCase					:					int      )   ->	Optional[Any]:
    _A      =       list(root.values()      )
    if len(__lowerCAmelCase      ) == 0:
       return 1
    else:
       return sum([self.count_leaves(__lowerCAmelCase      ) for nn in next_nodes]      )

 def     snake_case_      (    self					:					Optional[Any]			,						__lowerCAmelCase					:					Union[str, Any]			,						__lowerCAmelCase					:					str      )   ->	int:
    _A      =       self.count_leaves(__lowerCAmelCase      )
    return len(__lowerCAmelCase      ) != leaf_count


class 	lowerCamelCase__	(       _A):



 """simple docstring"""

 def __init__(    self					:					Optional[int]			,						__lowerCAmelCase					:					List[List[int]]      )   ->	Union[str, Any]:
    super(__lowerCAmelCase			,						self      ).__init__()

    if not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ) or len(__lowerCAmelCase      ) == 0:
       raise ValueError(f'''`nested_token_ids` has to be a non-empty list, but is {nested_token_ids}.'''      )
    if any(not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ) for token_ids in nested_token_ids      ):
       raise ValueError(f'''`nested_token_ids` has to be a list of lists, but is {nested_token_ids}.'''      )
    if any(
        any((not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ) or token_id < 0) for token_id in token_ids      )
        for token_ids in nested_token_ids      ):
       raise ValueError(
           f'''Each list in `nested_token_ids` has to be a list of positive integers, but is {nested_token_ids}.'''      )

    _A      =       DisjunctiveTrie(__lowerCAmelCase      )
    _A      =       nested_token_ids

    _A      =       self.trie.max_height
    _A      =       []
    _A      =       False

 def     snake_case_      (    self					:					str      )   ->	str:
    _A      =       self.trie.next_tokens(self.current_seq      )

    if len(__lowerCAmelCase      ) == 0:
       return None
    else:
       return token_list

 def     snake_case_      (    self					:					List[Any]			,						__lowerCAmelCase					:					int      )   ->	List[str]:
    if not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
       raise ValueError(f'''`token_id` is supposed to be type `int`, but is {token_id} of type {type(__lowerCAmelCase      )}'''      )

    _A      =       self.trie.next_tokens(self.current_seq      )

    return token_id in next_tokens

 def     snake_case_      (    self					:					List[Any]			,						__lowerCAmelCase					:					int      )   ->	Tuple:
    if not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
       raise ValueError(f'''`token_id` is supposed to be type `int`, but is {token_id} of type {type(__lowerCAmelCase      )}'''      )

    _A      =       False
    _A      =       False
    _A      =       False

    if self.does_advance(__lowerCAmelCase      ):
       self.current_seq.append(__lowerCAmelCase      )
       _A      =       True
    else:
       _A      =       True
       self.reset()

    _A      =       self.trie.reached_leaf(self.current_seq      )
    _A      =       completed

    return stepped, completed, reset

 def     snake_case_      (    self					:					Tuple      )   ->	int:
    _A      =       False
    _A      =       []

 def     snake_case_      (    self					:					Any      )   ->	List[str]:
    if self.completed:
       # since this can be completed without reaching max height
       return 0
    else:
       return self.seqlen - len(self.current_seq      )

 def     snake_case_      (    self					:					str			,						__lowerCAmelCase					:					Dict=False      )   ->	Optional[int]:
    _A      =       DisjunctiveConstraint(self.token_ids      )

    if stateful:
       _A      =       self.seqlen
       _A      =       self.current_seq
       _A      =       self.completed

    return new_constraint


class 	lowerCamelCase__	:



 """simple docstring"""

 def __init__(    self					:					Union[str, Any]			,						__lowerCAmelCase					:					List[Constraint]      )   ->	Optional[Any]:
    _A      =       constraints

    # max # of steps required to fulfill a given constraint
    _A      =       max([c.seqlen for c in constraints]      )
    _A      =       len(__lowerCAmelCase      )
    _A      =       False

    self.init_state()

 def     snake_case_      (    self					:					int      )   ->	str:
    _A      =       []
    _A      =       None
    _A      =       [constraint.copy(stateful=__lowerCAmelCase      ) for constraint in self.constraints]

 def     snake_case_      (    self					:					int      )   ->	Any:
    _A      =       0
    if self.inprogress_constraint:
       # extra points for having a constraint mid-fulfilled
       add += self.max_seqlen - self.inprogress_constraint.remaining()

    return (len(self.complete_constraints      ) * self.max_seqlen) + add

 def     snake_case_      (    self					:					Any      )   ->	str:
    _A      =       []
    if self.inprogress_constraint is None:
       for constraint in self.pending_constraints:  # "pending" == "unfulfilled yet"
          _A      =       constraint.advance()
          if isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
             token_list.append(__lowerCAmelCase      )
          elif isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
             token_list.extend(__lowerCAmelCase      )
    else:
       _A      =       self.inprogress_constraint.advance()
       if isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
          token_list.append(__lowerCAmelCase      )
       elif isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
          token_list.extend(__lowerCAmelCase      )

    if len(__lowerCAmelCase      ) == 0:
       return None
    else:
       return token_list

 def     snake_case_      (    self					:					List[str]			,						__lowerCAmelCase					:					Optional[List[int]]      )   ->	Dict:
    self.init_state()

    if token_ids is not None:
       for token in token_ids:
          # completes or steps **one** constraint
          _A  ,    _A      =       self.add(__lowerCAmelCase      )

          # the entire list of constraints are fulfilled
          if self.completed:
             break

 def     snake_case_      (    self					:					Any			,						__lowerCAmelCase					:					int      )   ->	Optional[int]:
    if not isinstance(__lowerCAmelCase			,						__lowerCAmelCase      ):
       raise ValueError(f'''`token_id` should be an `int`, but is `{token_id}`.'''      )

    _A  ,    _A      =       False, False

    if self.completed:
       _A      =       True
       _A      =       False
       return complete, stepped

    if self.inprogress_constraint is not None:
       # In the middle of fulfilling a constraint. If the `token_id` *does* makes an incremental progress to current
       # job, simply update the state

       _A  ,    _A  ,    _A      =       self.inprogress_constraint.update(__lowerCAmelCase      )
       if reset:
          # 1. If the next token breaks the progress, then we must restart.
          #     e.g. constraint = "I love pies" and sequence so far is "I love" but `token_id` == "books".

          #     But that doesn't mean we self.init_state(), since we only reset the state for this particular
          #     constraint, not the full list of constraints.

          self.pending_constraints.append(self.inprogress_constraint.copy(stateful=__lowerCAmelCase      )      )
          _A      =       None

       if complete:
          # 2. If the next token completes the constraint, move it to completed list, set
          #     inprogress to None. If there are no pending constraints either, then this full list of constraints
          #     is complete.

          self.complete_constraints.append(self.inprogress_constraint      )
          _A      =       None

          if len(self.pending_constraints      ) == 0:
             # we're done!
             _A      =       True

    else:
       # Not in the middle of fulfilling a constraint. So does this `token_id` helps us step towards any of our list
       # of constraints?

       for cidx, pending_constraint in enumerate(self.pending_constraints      ):
          if pending_constraint.does_advance(__lowerCAmelCase      ):
             _A  ,    _A  ,    _A      =       pending_constraint.update(__lowerCAmelCase      )

             if not stepped:
                raise Exception(
                    '''`constraint.update(token_id)` is not yielding incremental progress, '''
                    '''even though `constraint.does_advance(token_id)` is true.'''      )

             if complete:
                self.complete_constraints.append(__lowerCAmelCase      )
                _A      =       None

             if not complete and stepped:
                _A      =       pending_constraint

             if complete or stepped:
                # If we made any progress at all, then it's at least not a "pending constraint".

                _A      =       (
                    self.pending_constraints[:cidx] + self.pending_constraints[cidx + 1 :]
                )

                if len(self.pending_constraints      ) == 0 and self.inprogress_constraint is None:
                   # If there's no longer any pending after this and no inprogress either, then we must be
                   # complete.

                   _A      =       True

                break  # prevent accidentally stepping through multiple constraints with just one token.

    return complete, stepped

 def     snake_case_      (    self					:					Tuple			,						__lowerCAmelCase					:					Union[str, Any]=True      )   ->	Optional[Any]:
    _A      =       ConstraintListState(self.constraints      )  # we actually never though self.constraints objects
    # throughout this process. So it's at initialization state.

    if stateful:
       _A      =       [
           constraint.copy(stateful=__lowerCAmelCase      ) for constraint in self.complete_constraints
       ]
       if self.inprogress_constraint is not None:
          _A      =       self.inprogress_constraint.copy(stateful=__lowerCAmelCase      )
       _A      =       [constraint.copy() for constraint in self.pending_constraints]

    return new_state








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()



