


'''simple docstring'''

import collections
import os
import re
from pathlib import Path


a_    :							Optional[int]         =					"""src/transformers"""


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





def __snake_case   ( UpperCAmelCase_		:		Optional[int]						):







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





def __snake_case   ( UpperCAmelCase_		:		List[Any]						):







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

 lowerCamelCase_						=    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
 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(UpperCAmelCase_						):
   lowerCamelCase_						=    _re_one_line_import_struct.search(UpperCAmelCase_						).groups()[0]
   lowerCamelCase_						=    re.findall(r"\[([^\]]+)\]"   ,							UpperCAmelCase_						)
   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(UpperCAmelCase_						)
  if single_line_import_search is not None:
   lowerCamelCase_						=    [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

 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(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:
     lowerCamelCase_						=    _re_import_struct_add_many.search(UpperCAmelCase_						).groups()[0].split(", "						)
     lowerCamelCase_						=    [obj[1:-1] for obj in imports if len(UpperCAmelCase_						) > 0]
     objects.extend(UpperCAmelCase_						)
    elif _re_between_brackets.search(UpperCAmelCase_						) is not None:
     lowerCamelCase_						=    _re_between_brackets.search(UpperCAmelCase_						).groups()[0].split(", "						)
     lowerCamelCase_						=    [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

   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(UpperCAmelCase_						)
     and find_backend(lines[line_index]						) is None
     and not lines[line_index].startswith("else"						)
 ):
  lowerCamelCase_						=    lines[line_index]
  lowerCamelCase_						=    _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

 lowerCamelCase_						=    {"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.
  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(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

   lowerCamelCase_						=    objects
  else:
   line_index += 1

 return import_dict_objects, type_hint_objects





def __snake_case   ( UpperCAmelCase_		:		str   ,							UpperCAmelCase_		:		List[str]						):







 def find_duplicates(UpperCAmelCase_		:		List[str]						):
  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!"]

 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 __snake_case   ( ):
 lowerCamelCase_						=    []
 for root, _, files in os.walk(UpperCAmelCase_						):
  if "__init__.py" in files:
   lowerCamelCase_						=    os.path.join(UpperCAmelCase_   ,							"__init__.py"						)
   lowerCamelCase_						=    parse_init(UpperCAmelCase_						)
   if objects is not None:
    lowerCamelCase_						=    analyze_results(*UpperCAmelCase_						)
    if len(UpperCAmelCase_						) > 0:
     lowerCamelCase_						=    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 __snake_case   ( ):
 lowerCamelCase_						=    []
 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
   lowerCamelCase_						=    str((Path(UpperCAmelCase_						) / folder).relative_to(UpperCAmelCase_						)						)
   lowerCamelCase_						=    short_path.replace(os.path.sep   ,							"."						)
   submodules.append(UpperCAmelCase_						)
  for fname in files:
   if fname == "__init__.py":
    continue
   lowerCamelCase_						=    str((Path(UpperCAmelCase_						) / fname).relative_to(UpperCAmelCase_						)						)
   lowerCamelCase_						=    short_path.replace(".py"   ,							""						).replace(os.path.sep   ,							"."						)
   if len(submodule.split("."						)						) == 1:
    submodules.append(UpperCAmelCase_						)
 return submodules


a_    :							Optional[Any]         =					[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]





def __snake_case   ( ):
 from transformers.utils import direct_transformers_import

 lowerCamelCase_						=    direct_transformers_import(UpperCAmelCase_						)

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

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

 if len(UpperCAmelCase_						) > 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()






__lowercase				      =						[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
__lowercase				      =						[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
__lowercase				      =						{
    0: """Sunday""",
    1: """Monday""",
    2: """Tuesday""",
    3: """Wednesday""",
    4: """Thursday""",
    5: """Friday""",
    6: """Saturday""",
}







def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      assert len(str(SCREAMING_SNAKE_CASE   )   ) > 2, "year should be in YYYY format"
      assert 1 <= month <= 12, "month should be between 1 to 12"
      assert 1 <= day <= 31, "day should be between 1 to 31"

      # Doomsday algorithm:
      A_							       =		year // 100
      A_							       =		(5 * (century % 4) + 2) % 7
      A_							       =		year % 100
      A_							       =		centurian % 12
      A_							       =		(
          (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
      ) % 7
      A_							       =		(
          DOOMSDAY_NOT_LEAP[month - 1]
          if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
          else DOOMSDAY_LEAP[month - 1]
      )
      A_							       =		(dooms_day + day - day_anchor) % 7
      return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
      import doctest

      doctest.testmod()





