


'''simple docstring'''

import collections
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_						:       List[str]      			=				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_						:       List[str]      			=				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_						:       str      			=				re.compile(R"""^\s+\"([^\"]+)\",""")
# Catches a line with objects between brackets only:    ["foo", "bar"],
a_						:       List[Any]      			=				re.compile(R"""^\s+\[([^\]]+)\]""")
# Catches a line with from foo import bar, bla, boo
a_						:       Dict      			=				re.compile(R"""\s+from\s+\S*\s+import\s+([^\(\s].*)\n""")
# Catches a line with try:
a_						:       Tuple      			=				re.compile(R"""^\s*try:""")
# Catches a line with else:
a_						:       str      			=				re.compile(R"""^\s*else:""")





def __snake_case      (   UpperCAmelCase_		:		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_		:		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_		:		Union[str, Any]      ,       UpperCAmelCase_		:		Dict	):

 def find_duplicates(UpperCAmelCase_		:		Union[str, Any]	):
  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_						:       Any      			=				[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]





def __snake_case      (   ):
 # This is to make sure the transformers module imported is the one in the repo.
 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()







'''simple docstring'''

import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import load_iris
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier





def __snake_case      (   UpperCAmelCase_		:		dict	):
 return (data["data"], data["target"])





def __snake_case      (   UpperCAmelCase_		:		np.ndarray      ,       UpperCAmelCase_		:		np.ndarray	):
 lowerCamelCase_  				=						XGBClassifier()
 classifier.fit(UpperCAmelCase_      ,       UpperCAmelCase_	)
 return classifier





def __snake_case      (   ):
 lowerCamelCase_  				=						load_iris()
 lowerCamelCase_				,lowerCamelCase_  				=						data_handling(UpperCAmelCase_	)
 lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_  				=						train_test_split(
     UpperCAmelCase_      ,       UpperCAmelCase_      ,       test_size=0.25	)

 lowerCamelCase_  				=						iris["target_names"]

 # Create an XGBoost Classifier from the training data
 lowerCamelCase_  				=						xgboost(UpperCAmelCase_      ,       UpperCAmelCase_	)

 # Display the confusion matrix of the classifier with both training and test sets
 ConfusionMatrixDisplay.from_estimator(
     UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       display_labels=UpperCAmelCase_      ,       cmap="Blues"      ,       normalize="true"      ,       )
 plt.title("Normalized Confusion Matrix - IRIS Dataset"	)
 plt.show()


if __name__ == "__main__":
     import doctest

     doctest.testmod(verbose=True)
     main()



