






'''simple docstring'''





import collections
import os
import re
from pathlib import Path


__A							:							int  							=		'''src/transformers'''


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






def    lowerCamelCase_     (    lowercase__):




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






def    lowerCamelCase_     (    lowercase__):




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

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

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

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

 lowerCamelCase__  =     {"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.
  lowerCamelCase__  =     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:
   lowerCamelCase__  =     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

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

   lowerCamelCase__  =     objects
  else:
   line_index += 1

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

 lowerCamelCase__  =     {"none": objects}
 # Let's continue with backend-specific objects
 while line_index < len(lowercase__):
  # If the line is an if is_backend_available, we grab all objects associated.
  lowerCamelCase__  =     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:
   lowerCamelCase__  =     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

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

   lowerCamelCase__  =     objects
  else:
   line_index += 1

 return import_dict_objects, type_hint_objects






def    lowerCamelCase_     (    lowercase__				,     lowercase__):




 def find_duplicates(lowercase__):
  return [k for k, v in collections.Counter(lowercase__).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!"]

 lowerCamelCase__  =     []
 for key in import_dict_objects.keys():
  lowerCamelCase__  =     find_duplicates(import_dict_objects[key])
  if duplicate_imports:
   errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}''')
  lowerCamelCase__  =     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])):
   lowerCamelCase__  =     "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_     (    ):
 lowerCamelCase__  =     []
 for root, _, files in os.walk(lowercase__):
  if "__init__.py" in files:
   lowerCamelCase__  =     os.path.join(lowercase__				,     "__init__.py")
   lowerCamelCase__  =     parse_init(lowercase__)
   if objects is not None:
    lowerCamelCase__  =     analyze_results(*lowercase__)
    if len(lowercase__) > 0:
     lowerCamelCase__  =     F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
     failures.append("\n".join(lowercase__))
 if len(lowercase__) > 0:
  raise ValueError("\n\n".join(lowercase__))






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


__A							:							List[str]  							=		[
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
    '''models.esm.openfold_utils''',
]






def    lowerCamelCase_     (    ):
 from transformers.utils import direct_transformers_import

 lowerCamelCase__  =     direct_transformers_import(lowercase__)

 lowerCamelCase__  =     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(lowercase__				,     "__init__.py")				,     "r") as f:
  lowerCamelCase__  =     f.read()
 import_structure_keys.update(set(re.findall(r"import_structure\[\"([^\"]*)\"\]"				,     lowercase__)))

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

 if len(lowercase__) > 0:
  lowerCamelCase__  =     "\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()









'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


__A							:							Union[str, Any]  							=		{
    """configuration_layoutlmv2""": ["""LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LayoutLMv2Config"""],
    """processing_layoutlmv2""": ["""LayoutLMv2Processor"""],
    """tokenization_layoutlmv2""": ["""LayoutLMv2Tokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A							:							Optional[Any]  							=		["""LayoutLMv2TokenizerFast"""]

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A							:							List[Any]  							=		["""LayoutLMv2FeatureExtractor"""]
 __A							:							List[Any]  							=		["""LayoutLMv2ImageProcessor"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A							:							Any  							=		[
     """LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """LayoutLMv2ForQuestionAnswering""",
     """LayoutLMv2ForSequenceClassification""",
     """LayoutLMv2ForTokenClassification""",
     """LayoutLMv2Layer""",
     """LayoutLMv2Model""",
     """LayoutLMv2PreTrainedModel""",
 ]

if TYPE_CHECKING:
 from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
 from .processing_layoutlmva import LayoutLMvaProcessor
 from .tokenization_layoutlmva import LayoutLMvaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_layoutlmva import (
      LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
      LayoutLMvaForQuestionAnswering,
      LayoutLMvaForSequenceClassification,
      LayoutLMvaForTokenClassification,
      LayoutLMvaLayer,
      LayoutLMvaModel,
      LayoutLMvaPreTrainedModel,
  )
else:
 import sys

 __A							:							Tuple  							=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

