





'''simple docstring'''

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


a        =						"src/transformers"


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

def 						__magic_name__       (							__UpperCAmelCase      )						->					Tuple:

   '''simple docstring'''







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

def 						__magic_name__       (							__UpperCAmelCase      )						->					Optional[int]:

   '''simple docstring'''







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

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

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

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

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

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

         __SCREAMING_SNAKE_CASE      							=       objects
      else:
         line_index += 1

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

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

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

         __SCREAMING_SNAKE_CASE      							=       objects
      else:
         line_index += 1

   return import_dict_objects, type_hint_objects

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					Tuple:

   '''simple docstring'''







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

   __SCREAMING_SNAKE_CASE      							=       []
   for key in import_dict_objects.keys():
      __SCREAMING_SNAKE_CASE      							=       find_duplicates(import_dict_objects[key]      )
      if duplicate_imports:
         errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""      )
      __SCREAMING_SNAKE_CASE      							=       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]      )      ):
         __SCREAMING_SNAKE_CASE      							=       """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 						__magic_name__       (							)						->					str:

   '''simple docstring'''







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

def 						__magic_name__       (							)						->					str:

   '''simple docstring'''







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


a        =						[
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
]

def 						__magic_name__       (							)						->					Tuple:

   '''simple docstring'''







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

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












'''simple docstring'''

from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
    if not (is_transformers_available() and is_torch_available()):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
    from .multicontrolnet import MultiControlNetModel
    from .pipeline_controlnet import StableDiffusionControlNetPipeline
    from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
    from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
    from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline





