






'''simple docstring'''



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


SCREAMING_SNAKE_CASE							=						'src/transformers'


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


def 				lowercase_					(     __A			:							Any      )							->   Any:



 """simple docstring"""




 if _re_test_backend.search(__A      ) is None:
  return None
 lowercase       : Union[str, Any]						=[b[0] for b in _re_backend.findall(__A      )]
 backends.sort()
 return "_and_".join(__A      )


def 				lowercase_					(     __A			:							int      )							->   Optional[Any]:



 """simple docstring"""




 with open(__A       ,   '''r'''       ,   encoding='''utf-8'''       ,   newline='''\n'''      ) as f:
  lowercase       : List[str]						=f.readlines()

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

 lowercase       : List[Any]						={'''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.
  lowercase       : List[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:
   lowercase       : Union[str, 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

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

   lowercase       : int						=objects
  else:
   line_index += 1

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

 lowercase       : Union[str, Any]						={'''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.
  lowercase       : str						=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:
   lowercase       : 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

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

   lowercase       : List[str]						=objects
  else:
   line_index += 1

 return import_dict_objects, type_hint_objects


def 				lowercase_					(     __A			:							Dict       ,   __A			:							Union[str, Any]      )							->   Dict:



 """simple docstring"""




 def find_duplicates(__A			:							Optional[Any]      ):
  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!"]

 lowercase       : str						=[]
 for key in import_dict_objects.keys():
  lowercase       : int						=find_duplicates(import_dict_objects[key]      )
  if duplicate_imports:
   errors.append(F'Duplicate _import_structure definitions for: {duplicate_imports}'      )
  lowercase       : Optional[Any]						=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]      )      ):
   lowercase       : int						='''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_					(     )							->   Dict:



 """simple docstring"""




 lowercase       : List[Any]						=[]
 for root, _, files in os.walk(__A      ):
  if "__init__.py" in files:
   lowercase       : List[Any]						=os.path.join(__A       ,   '''__init__.py'''      )
   lowercase       : Optional[int]						=parse_init(__A      )
   if objects is not None:
    lowercase       : Optional[int]						=analyze_results(*__A      )
    if len(__A      ) > 0:
     lowercase       : Optional[Any]						=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 				lowercase_					(     )							->   Union[str, Any]:



 """simple docstring"""




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


SCREAMING_SNAKE_CASE							=						[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]


def 				lowercase_					(     )							->   Optional[Any]:



 """simple docstring"""




 lowercase       : str						=importlib.util.spec_from_file_location(
     '''transformers'''       ,   os.path.join(__A       ,   '''__init__.py'''      )       ,   submodule_search_locations=[PATH_TO_TRANSFORMERS]       ,   )
 lowercase       : Optional[int]						=spec.loader.load_module()

 lowercase       : str						=[
     module
     for module in get_transformers_submodules()
     if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
 ]
 if len(__A      ) > 0:
  lowercase       : Optional[int]						='''\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 qiskit


def     lowercase	(    a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:int				     =						qiskit.Aer.get_backend("aer_simulator" )

		# Create a Quantum Circuit acting on the q register
		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						qiskit.QuantumCircuit(a     , a )

		# Apply X (NOT) Gate to Qubits 0 & 1
		circuit.x(0 )
		circuit.x(1 )

		# Map the quantum measurement to the classical bits
		circuit.measure([0, 1]     , [0, 1] )

		# Execute the circuit on the qasm simulator
		SCREAMING_SNAKE_CASE_				:Any				     =						qiskit.execute(a     , a     , shots=1000 )

		# Return the histogram data of the results of the experiment.
		return job.result().get_counts(a )


if __name__ == "__main__":
		SCREAMING_SNAKE_CASE__     					=			single_qubit_measure(2, 2)
		print(F'''Total count for various states are: {counts}''')






