






"""simple docstring"""
import collections
import os
import re
from pathlib import Path


lowerCAmelCase__    						=			'src/transformers'


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





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





def 				lowercase__		(					lowerCamelCase       ):
				with open(lowerCamelCase,						'r',						encoding='utf-8',						newline='\n'       ) as f:
								_SCREAMING_SNAKE_CASE   :		Dict       		=    f.readlines()

				_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    0
				while line_index < len(lowerCamelCase       ) and not lines[line_index].startswith('_import_structure = {'       ):
								line_index += 1

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

				# First grab the objects without a specific backend in _import_structure
				_SCREAMING_SNAKE_CASE   :		int       		=    []
				while not lines[line_index].startswith('if TYPE_CHECKING'       ) and find_backend(lines[line_index]       ) is None:
								_SCREAMING_SNAKE_CASE   :		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(lowerCamelCase       ):
												_SCREAMING_SNAKE_CASE   :		int       		=    _re_one_line_import_struct.search(lowerCamelCase       ).groups()[0]
												_SCREAMING_SNAKE_CASE   :		Any       		=    re.findall(R'\[([^\]]+)\]',						lowerCamelCase       )
												for imp in imports:
																objects.extend([obj[1:-1] for obj in imp.split(', '       )]       )
												line_index += 1
												continue
								_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    _re_import_struct_key_value.search(lowerCamelCase       )
								if single_line_import_search is not None:
												_SCREAMING_SNAKE_CASE   :		Any       		=    [obj[1:-1] for obj in single_line_import_search.groups()[0].split(', '       ) if len(lowerCamelCase       ) > 0]
												objects.extend(lowerCamelCase       )
								elif line.startswith(' ' * 8 + '"'       ):
												objects.append(line[9:-3]       )
								line_index += 1

				_SCREAMING_SNAKE_CASE   :		Tuple       		=    {'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   :		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:
												_SCREAMING_SNAKE_CASE   :		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

												_SCREAMING_SNAKE_CASE   :		List[Any]       		=    []
												# Until we unindent, add backend objects to the list
												while len(lines[line_index]       ) <= 1 or lines[line_index].startswith(' ' * 4       ):
																_SCREAMING_SNAKE_CASE   :		Dict       		=    lines[line_index]
																if _re_import_struct_add_one.search(lowerCamelCase       ) is not None:
																				objects.append(_re_import_struct_add_one.search(lowerCamelCase       ).groups()[0]       )
																elif _re_import_struct_add_many.search(lowerCamelCase       ) is not None:
																				_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    _re_import_struct_add_many.search(lowerCamelCase       ).groups()[0].split(', '       )
																				_SCREAMING_SNAKE_CASE   :		Dict       		=    [obj[1:-1] for obj in imports if len(lowerCamelCase       ) > 0]
																				objects.extend(lowerCamelCase       )
																elif _re_between_brackets.search(lowerCamelCase       ) is not None:
																				_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    _re_between_brackets.search(lowerCamelCase       ).groups()[0].split(', '       )
																				_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    [obj[1:-1] for obj in imports if len(lowerCamelCase       ) > 0]
																				objects.extend(lowerCamelCase       )
																elif _re_quote_object.search(lowerCamelCase       ) is not None:
																				objects.append(_re_quote_object.search(lowerCamelCase       ).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   :		Dict       		=    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   :		List[str]       		=    []
				while (
				    line_index < len(lowerCamelCase       )
				    and find_backend(lines[line_index]       ) is None
				    and not lines[line_index].startswith('else'       )
				):
								_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    lines[line_index]
								_SCREAMING_SNAKE_CASE   :		List[Any]       		=    _re_import.search(lowerCamelCase       )
								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   :		Any       		=    {'none': objects}
				# Let's continue with backend-specific objects
				while line_index < len(lowerCamelCase       ):
								# If the line is an if is_backend_available, we grab all objects associated.
								_SCREAMING_SNAKE_CASE   :		Tuple       		=    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   :		List[str]       		=    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   :		Optional[Any]       		=    []
												# Until we unindent, add backend objects to the list
												while len(lines[line_index]       ) <= 1 or lines[line_index].startswith(' ' * 8       ):
																_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    lines[line_index]
																_SCREAMING_SNAKE_CASE   :		str       		=    _re_import.search(lowerCamelCase       )
																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   :		List[Any]       		=    objects
								else:
												line_index += 1

				return import_dict_objects, type_hint_objects





def 				lowercase__		(					lowerCamelCase,						lowerCamelCase       ):

				def find_duplicates(lowerCamelCase       ):
								return [k for k, v in collections.Counter(lowerCamelCase       ).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   :		List[Any]       		=    []
				for key in import_dict_objects.keys():
								_SCREAMING_SNAKE_CASE   :		List[Any]       		=    find_duplicates(import_dict_objects[key]       )
								if duplicate_imports:
												errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""       )
								_SCREAMING_SNAKE_CASE   :		str       		=    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   :		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__		(					):
				_SCREAMING_SNAKE_CASE   :		Tuple       		=    []
				for root, _, files in os.walk(lowerCamelCase       ):
								if "__init__.py" in files:
												_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    os.path.join(lowerCamelCase,						'__init__.py'       )
												_SCREAMING_SNAKE_CASE   :		str       		=    parse_init(lowerCamelCase       )
												if objects is not None:
																_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    analyze_results(*lowerCamelCase       )
																if len(lowerCamelCase       ) > 0:
																				_SCREAMING_SNAKE_CASE   :		Dict       		=    f"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
																				failures.append('\n'.join(lowerCamelCase       )       )
				if len(lowerCamelCase       ) > 0:
								raise ValueError('\n\n'.join(lowerCamelCase       )       )





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


lowerCAmelCase__    						=			[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
    'models.esm.openfold_utils',
]





def 				lowercase__		(					):
				# This is to make sure the transformers module imported is the one in the repo.
				from transformers.utils import direct_transformers_import

				_SCREAMING_SNAKE_CASE   :		List[str]       		=    direct_transformers_import(lowerCamelCase       )

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

				_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    [
				    module
				    for module in get_transformers_submodules()
				    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
				]

				if len(lowerCamelCase       ) > 0:
								_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    '\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 functools
import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


lowerCAmelCase__    						=			threading.Lock()
lowerCAmelCase__    						=			None

lowerCAmelCase__    						=			{
    'debug': logging.DEBUG,
    'info': logging.INFO,
    'warning': logging.WARNING,
    'error': logging.ERROR,
    'critical': logging.CRITICAL,
}

lowerCAmelCase__    						=			logging.WARNING

lowerCAmelCase__    						=			True





def 				lowercase__		(					):
				_SCREAMING_SNAKE_CASE   :		int       		=    os.getenv('TRANSFORMERS_VERBOSITY',						lowerCamelCase       )
				if env_level_str:
								if env_level_str in log_levels:
												return log_levels[env_level_str]
								else:
												logging.getLogger().warning(
												    f"""Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, """
												    f"""has to be one of: { ", ".join(log_levels.keys()       ) }"""       )
				return _default_log_level





def 				lowercase__		(					):
				return __name__.split('.'       )[0]





def 				lowercase__		(					):
				return logging.getLogger(_get_library_name()       )





def 				lowercase__		(					):
				global _default_handler

				with _lock:
								if _default_handler:
												# This library has already configured the library root logger.
												return
								_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    logging.StreamHandler()  # Set sys.stderr as stream.
								_SCREAMING_SNAKE_CASE   :		Tuple       		=    sys.stderr.flush

								# Apply our default configuration to the library root logger.
								_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    _get_library_root_logger()
								library_root_logger.addHandler(_default_handler       )
								library_root_logger.setLevel(_get_default_logging_level()       )
								_SCREAMING_SNAKE_CASE   :		int       		=    False





def 				lowercase__		(					):
				global _default_handler

				with _lock:
								if not _default_handler:
												return

								_SCREAMING_SNAKE_CASE   :		Any       		=    _get_library_root_logger()
								library_root_logger.removeHandler(_default_handler       )
								library_root_logger.setLevel(logging.NOTSET       )
								_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    None





def 				lowercase__		(					):
				return log_levels





def 				lowercase__		(					lowerCamelCase = None       ):

				if name is None:
								_SCREAMING_SNAKE_CASE   :		Tuple       		=    _get_library_name()

				_configure_library_root_logger()
				return logging.getLogger(lowerCamelCase       )





def 				lowercase__		(					):
				_configure_library_root_logger()
				return _get_library_root_logger().getEffectiveLevel()





def 				lowercase__		(					lowerCamelCase       ):
				_configure_library_root_logger()
				_get_library_root_logger().setLevel(lowerCamelCase       )





def 				lowercase__		(					):
				return set_verbosity(lowerCamelCase       )





def 				lowercase__		(					):
				return set_verbosity(lowerCamelCase       )





def 				lowercase__		(					):
				return set_verbosity(lowerCamelCase       )





def 				lowercase__		(					):
				return set_verbosity(lowerCamelCase       )





def 				lowercase__		(					):
				_configure_library_root_logger()

				assert _default_handler is not None
				_get_library_root_logger().removeHandler(_default_handler       )





def 				lowercase__		(					):
				_configure_library_root_logger()

				assert _default_handler is not None
				_get_library_root_logger().addHandler(_default_handler       )





def 				lowercase__		(					lowerCamelCase       ):
				_configure_library_root_logger()

				assert handler is not None
				_get_library_root_logger().addHandler(lowerCamelCase       )





def 				lowercase__		(					lowerCamelCase       ):
				_configure_library_root_logger()

				assert handler is not None and handler not in _get_library_root_logger().handlers
				_get_library_root_logger().removeHandler(lowerCamelCase       )





def 				lowercase__		(					):
				_configure_library_root_logger()
				_SCREAMING_SNAKE_CASE   :		List[str]       		=    False





def 				lowercase__		(					):
				_configure_library_root_logger()
				_SCREAMING_SNAKE_CASE   :		int       		=    True





def 				lowercase__		(					):
				_SCREAMING_SNAKE_CASE   :		Any       		=    _get_library_root_logger().handlers

				for handler in handlers:
								_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    logging.Formatter('[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'       )
								handler.setFormatter(lowerCamelCase       )





def 				lowercase__		(					):
				_SCREAMING_SNAKE_CASE   :		List[str]       		=    _get_library_root_logger().handlers

				for handler in handlers:
								handler.setFormatter(lowerCamelCase       )





def 				lowercase__		(					self,						*lowerCamelCase,						**lowerCamelCase       ):
				_SCREAMING_SNAKE_CASE   :		str       		=    os.getenv('TRANSFORMERS_NO_ADVISORY_WARNINGS',						lowerCamelCase       )
				if no_advisory_warnings:
								return
				self.warning(*lowerCamelCase,						**lowerCamelCase       )


lowerCAmelCase__    						=			warning_advice





@functools.lru_cache(lowerCamelCase       )
def 				lowercase__		(					self,						*lowerCamelCase,						**lowerCamelCase       ):
				self.warning(*lowerCamelCase,						**lowerCamelCase       )


lowerCAmelCase__    						=			warning_once


class _lowerCAmelCase						:







						def __init__(    self   ,				*lowerCAmelCase_   ,				**lowerCAmelCase_							)		->							Optional[int]:  # pylint: disable=unused-argument
										_SCREAMING_SNAKE_CASE   :		Tuple       		=    args[0] if args else None







						def __iter__(    self							)		->							Dict:
										return iter(self._iterator							)







						def __getattr__(    self   ,				lowerCAmelCase_							)		->							Tuple:

										def empty_fn(*lowerCAmelCase_   ,				**lowerCAmelCase_							):  # pylint: disable=unused-argument
														return

										return empty_fn







						def __enter__(    self							)		->							List[Any]:
										return self







						def __exit__(    self   ,				lowerCAmelCase_   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)		->							Optional[Any]:
										return







class _lowerCAmelCase						:







						def __call__(    self   ,				*lowerCAmelCase_   ,				**lowerCAmelCase_							)		->							Optional[Any]:
										if _tqdm_active:
														return tqdm_lib.tqdm(*lowerCAmelCase_   ,				**lowerCAmelCase_							)
										else:
														return EmptyTqdm(*lowerCAmelCase_   ,				**lowerCAmelCase_							)







						def 			A      (    self   ,				*lowerCAmelCase_   ,				**lowerCAmelCase_							)		->							List[str]:
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    None
										if _tqdm_active:
														return tqdm_lib.tqdm.set_lock(*lowerCAmelCase_   ,				**lowerCAmelCase_							)







						def 			A      (    self							)		->							Any:
										if _tqdm_active:
														return tqdm_lib.tqdm.get_lock()







lowerCAmelCase__    						=			_tqdm_cls()





def 				lowercase__		(					):
				global _tqdm_active
				return bool(_tqdm_active       )





def 				lowercase__		(					):
				global _tqdm_active
				_SCREAMING_SNAKE_CASE   :		int       		=    True
				hf_hub_utils.enable_progress_bars()






def 				lowercase__		(					):
				global _tqdm_active
				_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    False
				hf_hub_utils.disable_progress_bars()

