






'''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 				a						( _UpperCAmelCase			)					->					Dict:






					"""simple docstring"""







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

def 				a						( _UpperCAmelCase			)					->					Dict:






					"""simple docstring"""







					with open(_A       ,	'r'       ,	encoding='utf-8'       ,	newline='\n'			) as f:
										a_						= f.readlines()

					a_						= 0
					while line_index < len(_A			) and not lines[line_index].startswith('_import_structure = {'			):
										line_index += 1

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

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

					a_						= {'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.
										a_						= 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:
															a_						= 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

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

															a_						= objects
										else:
															line_index += 1

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

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

															a_						= []
															# Until we unindent, add backend objects to the list
															while len(lines[line_index]			) <= 1 or lines[line_index].startswith(' ' * 8			):
																				a_						= lines[line_index]
																				a_						= _re_import.search(_A			)
																				if single_line_import_search is not None:
																									objects.extend(single_line_import_search.groups()[0].split(', '			)			)
																				elif line.startswith(' ' * 1_2			):
																									objects.append(line[1_2:-2]			)
																				line_index += 1

															a_						= objects
										else:
															line_index += 1

					return import_dict_objects, type_hint_objects

def 				a						( _UpperCAmelCase       ,	_UpperCAmelCase			)					->					int:






					"""simple docstring"""







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

					a_						= []
					for key in import_dict_objects.keys():
										a_						= find_duplicates(import_dict_objects[key]			)
										if duplicate_imports:
															errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''			)
										a_						= 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]			)			):
															a_						= '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 				a						( )					->					List[Any]:






					"""simple docstring"""







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

def 				a						( )					->					Tuple:






					"""simple docstring"""







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


__lowerCAmelCase				=[
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
    "models.esm.openfold_utils",
]

def 				a						( )					->					List[Any]:






					"""simple docstring"""







					from transformers.utils import direct_transformers_import

					a_						= direct_transformers_import(_A			)

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

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

					if len(_A			) > 0:
										a_						= '\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'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowercase        =    {
    '''configuration_chinese_clip''': [
        '''CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''ChineseCLIPConfig''',
        '''ChineseCLIPOnnxConfig''',
        '''ChineseCLIPTextConfig''',
        '''ChineseCLIPVisionConfig''',
    ],
    '''processing_chinese_clip''': ['''ChineseCLIPProcessor'''],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase        =    ['''ChineseCLIPFeatureExtractor''']
						__lowercase        =    ['''ChineseCLIPImageProcessor''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase        =    [
						    '''CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''ChineseCLIPModel''',
						    '''ChineseCLIPPreTrainedModel''',
						    '''ChineseCLIPTextModel''',
						    '''ChineseCLIPVisionModel''',
						]

if TYPE_CHECKING:
						from .configuration_chinese_clip import (
						    CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    ChineseCLIPConfig,
						    ChineseCLIPOnnxConfig,
						    ChineseCLIPTextConfig,
						    ChineseCLIPVisionConfig,
						)
						from .processing_chinese_clip import ChineseCLIPProcessor

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_chinese_clip import (
												    CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ChineseCLIPModel,
												    ChineseCLIPPreTrainedModel,
												    ChineseCLIPTextModel,
												    ChineseCLIPVisionModel,
												)

else:
						import sys

						__lowercase        =    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




