


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


A				:       Union[str, Any]      =  'src/transformers'


# Matches is_xxx_available()
A				:       str      =  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				:       Dict      =  re.compile(r'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
A				:       Dict      =  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				:       Optional[int]      =  re.compile('^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
A				:       str      =  re.compile('^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
A				:       Union[str, Any]      =  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 						_lowerCAmelCase							(     _lowerCAmelCase			)    ->						List[Any]:


						'''simple docstring'''






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





def 						_lowerCAmelCase							(     _lowerCAmelCase			)    ->						Optional[int]:


						'''simple docstring'''






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

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

						__snake_case				=		{"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.
												__snake_case				=		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:
																		__snake_case				=		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

																		__snake_case				=		[]
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]			) <= 1 or lines[line_index].startswith(" " * 4			):
																								__snake_case				=		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:
																														__snake_case				=		_re_import_struct_add_many.search(_lowerCAmelCase			).groups()[0].split(", "			)
																														__snake_case				=		[obj[1:-1] for obj in imports if len(_lowerCAmelCase			) > 0]
																														objects.extend(_lowerCAmelCase			)
																								elif _re_between_brackets.search(_lowerCAmelCase			) is not None:
																														__snake_case				=		_re_between_brackets.search(_lowerCAmelCase			).groups()[0].split(", "			)
																														__snake_case				=		[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

																		__snake_case				=		objects
												else:
																		line_index += 1

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

						__snake_case				=		{"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.
												__snake_case				=		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:
																		__snake_case				=		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

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

																		__snake_case				=		objects
												else:
																		line_index += 1

						return import_dict_objects, type_hint_objects





def 						_lowerCAmelCase							(     _lowerCAmelCase   ,						_lowerCAmelCase			)    ->						Optional[Any]:


						'''simple docstring'''






						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!"]

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


						'''simple docstring'''






						__snake_case				=		[]
						for root, _, files in os.walk(_lowerCAmelCase			):
												if "__init__.py" in files:
																		__snake_case				=		os.path.join(_lowerCAmelCase   ,						"__init__.py"			)
																		__snake_case				=		parse_init(_lowerCAmelCase			)
																		if objects is not None:
																								__snake_case				=		analyze_results(*_lowerCAmelCase			)
																								if len(_lowerCAmelCase			) > 0:
																														__snake_case				=		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 						_lowerCAmelCase							(     )    ->						Dict:


						'''simple docstring'''






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


A				:       List[Any]      =  [
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]





def 						_lowerCAmelCase							(     )    ->						Any:


						'''simple docstring'''






						__snake_case				=		importlib.util.spec_from_file_location(
						    "transformers"   ,						os.path.join(_lowerCAmelCase   ,						"__init__.py"			)   ,						submodule_search_locations=[PATH_TO_TRANSFORMERS]   ,						)
						__snake_case				=		spec.loader.load_module()

						__snake_case				=		[
						    module
						    for module in get_transformers_submodules()
						    if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
						]
						if len(_lowerCAmelCase			) > 0:
												__snake_case				=		"\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()









import requests
from bsa import BeautifulSoup





def 						_lowerCAmelCase							(     _lowerCAmelCase = "AAPL"			)    ->						str:


						'''simple docstring'''






						__snake_case				=		F'''https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'''
						__snake_case				=		BeautifulSoup(requests.get(_lowerCAmelCase			).text   ,						"html.parser"			)
						__snake_case				=		"My(6px) Pos(r) smartphone_Mt(6px)"
						return soup.find("div"   ,						class_=class_			).find("span"			).text


if __name__ == "__main__":
	for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
		print(f'''Current {symbol:<4} stock price is {stock_price(symbol):>8}''')





