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


_a   :	List[str] 							=   'src/transformers'


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

def _lowercase	(      lowerCamelCase__						)					->       List[str]:





       """simple docstring"""


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

def _lowercase	(      lowerCamelCase__						)					->       str:





       """simple docstring"""


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

       __UpperCAmelCase  :				Optional[Any]       				=		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
       __UpperCAmelCase  :				Union[str, Any]       				=		[]
       while not lines[line_index].startswith("if TYPE_CHECKING"						) and find_backend(lines[line_index]						) is None:
              __UpperCAmelCase  :				Optional[Any]       				=		lines[line_index]
              # If we have everything on a single line, let's deal with it.
              if _re_one_line_import_struct.search(__UpperCamelCase						):
                     __UpperCAmelCase  :				Dict       				=		_re_one_line_import_struct.search(__UpperCamelCase						).groups()[0]
                     __UpperCAmelCase  :				str       				=		re.findall("\[([^\]]+)\]"							,    __UpperCamelCase						)
                     for imp in imports:
                            objects.extend([obj[1:-1] for obj in imp.split(", "						)]						)
                     line_index += 1
                     continue
              __UpperCAmelCase  :				Union[str, Any]       				=		_re_import_struct_key_value.search(__UpperCamelCase						)
              if single_line_import_search is not None:
                     __UpperCAmelCase  :				Union[str, Any]       				=		[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

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

                     __UpperCAmelCase  :				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  :				Union[str, Any]       				=		[]
       while (
           line_index < len(__UpperCamelCase						)
           and find_backend(lines[line_index]						) is None
           and not lines[line_index].startswith("else"						)
       ):
              __UpperCAmelCase  :				Optional[int]       				=		lines[line_index]
              __UpperCAmelCase  :				Union[str, Any]       				=		_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

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

                     __UpperCAmelCase  :				List[str]       				=		objects
              else:
                     line_index += 1

       return import_dict_objects, type_hint_objects

def _lowercase	(      lowerCamelCase__							,    lowerCamelCase__						)					->       int:





       """simple docstring"""


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

       __UpperCAmelCase  :				Any       				=		[]
       for key in import_dict_objects.keys():
              __UpperCAmelCase  :				Optional[int]       				=		find_duplicates(import_dict_objects[key]						)
              if duplicate_imports:
                     errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""						)
              __UpperCAmelCase  :				Union[str, Any]       				=		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 _lowercase	(      )					->       Optional[int]:





       """simple docstring"""


       __UpperCAmelCase  :				List[Any]       				=		[]
       for root, _, files in os.walk(__UpperCamelCase						):
              if "__init__.py" in files:
                     __UpperCAmelCase  :				Tuple       				=		os.path.join(__UpperCamelCase							,    "__init__.py"						)
                     __UpperCAmelCase  :				str       				=		parse_init(__UpperCamelCase						)
                     if objects is not None:
                            __UpperCAmelCase  :				int       				=		analyze_results(*__UpperCamelCase						)
                            if len(__UpperCamelCase						) > 0:
                                   __UpperCAmelCase  :				Any       				=		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 _lowercase	(      )					->       List[str]:





       """simple docstring"""


       __UpperCAmelCase  :				Any       				=		[]
       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
                     __UpperCAmelCase  :				List[str]       				=		str((Path(__UpperCamelCase						) / folder).relative_to(__UpperCamelCase						)						)
                     __UpperCAmelCase  :				Optional[int]       				=		short_path.replace(os.path.sep							,    "."						)
                     submodules.append(__UpperCamelCase						)
              for fname in files:
                     if fname == "__init__.py":
                            continue
                     __UpperCAmelCase  :				Union[str, Any]       				=		str((Path(__UpperCamelCase						) / fname).relative_to(__UpperCamelCase						)						)
                     __UpperCAmelCase  :				List[Any]       				=		short_path.replace(".py"							,    ""						).replace(os.path.sep							,    "."						)
                     if len(submodule.split("."						)						) == 1:
                            submodules.append(__UpperCamelCase						)
       return submodules


_a   :	Tuple 							=   [
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]

def _lowercase	(      )					->       str:





       """simple docstring"""


       __UpperCAmelCase  :				List[Any]       				=		importlib.util.spec_from_file_location(
           "transformers"							,    os.path.join(__UpperCamelCase							,    "__init__.py"						)							,    submodule_search_locations=[PATH_TO_TRANSFORMERS]							,    )
       __UpperCAmelCase  :				Optional[Any]       				=		spec.loader.load_module()

       __UpperCAmelCase  :				Any       				=		[
           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:
              __UpperCAmelCase  :				List[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()







'''simple docstring'''




def _lowercase	(      lowerCamelCase__							,    lowerCamelCase__						)					->       float:





       """simple docstring"""


       if discount_rate < 0:
              raise ValueError("Discount rate cannot be negative"						)
       if not cash_flows:
              raise ValueError("Cash flows list cannot be empty"						)
       __UpperCAmelCase  :				Tuple       				=		sum(
           cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(lowerCamelCase__						)						)
       return round(lowerCamelCase__							,    ndigits=2						)


if __name__ == "__main__":
   import doctest

   doctest.testmod()






