





'''simple docstring'''

from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
		import tensorflow as tf


__lowerCAmelCase							:     Union[str, Any]		     =logging.get_logger(__name__)






@dataclass
class        UpperCAmelCase     (	UpperCamelCase__    ):
	__lowercase       		=    [
	    """no_inference""",
	    """no_cuda""",
	    """no_tpu""",
	    """no_speed""",
	    """no_memory""",
	    """no_env_print""",
	    """no_multi_process""",
	]
	def __init__(    self				:Tuple						,	**lowercase_				:List[str]							)->							str:
					for deprecated_arg in self.deprecated_args:
									if deprecated_arg in kwargs:
													A__    =      deprecated_arg[3:]
													A__    =      not kwargs.pop(lowercase_							)
													logger.warning(
													    F"{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"
													    F" {positive_arg}={kwargs[positive_arg]}"							)
					A__    =      kwargs.pop("tpu_name"						,	self.tpu_name							)
					A__    =      kwargs.pop("device_idx"						,	self.device_idx							)
					A__    =      kwargs.pop("eager_mode"						,	self.eager_mode							)
					A__    =      kwargs.pop("use_xla"						,	self.use_xla							)
					super().__init__(**lowercase_							)

	__lowercase       		=    field(
	    default=UpperCamelCase__      ,	metadata={"""help""": """Name of TPU"""}      ,	)
	__lowercase       		=    field(
	    default=0      ,	metadata={"""help""": """CPU / GPU device index. Defaults to 0."""}      ,	)
	__lowercase       		=    field(default=UpperCamelCase__      ,	metadata={"""help""": """Benchmark models in eager model."""}    )
	__lowercase       		=    field(
	    default=UpperCamelCase__      ,	metadata={
	        """help""": """Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."""
	    }      ,	)
	@cached_property
	def 					UpperCAmelCase_							(    self				:int							)->							Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:
					requires_backends(self						,	["tf"]							)
					A__    =      None
					if self.tpu:
									try:
													if self.tpu_name:
																	A__    =      tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name							)
													else:
																	A__    =      tf.distribute.cluster_resolver.TPUClusterResolver()
									except ValueError:
													A__    =      None
					return tpu
	@cached_property
	def 					UpperCAmelCase_							(    self				:int							)->							Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:
					requires_backends(self						,	["tf"]							)
					if self.is_tpu:
									tf.config.experimental_connect_to_cluster(self._setup_tpu							)
									tf.tpu.experimental.initialize_tpu_system(self._setup_tpu							)

									A__    =      tf.distribute.TPUStrategy(self._setup_tpu							)
					else:
									# currently no multi gpu is allowed
									if self.is_gpu:
													# TODO: Currently only single GPU is supported
													tf.config.set_visible_devices(self.gpu_list[self.device_idx]						,	"GPU"							)
													A__    =      tf.distribute.OneDeviceStrategy(device=F"/gpu:{self.device_idx}"							)
									else:
													tf.config.set_visible_devices([]						,	"GPU"							)  # disable GPU
													A__    =      tf.distribute.OneDeviceStrategy(device=F"/cpu:{self.device_idx}"							)

					return strategy
	@property
	def 					UpperCAmelCase_							(    self				:List[str]							)->							bool:
					requires_backends(self						,	["tf"]							)
					return self._setup_tpu is not None
	@property
	def 					UpperCAmelCase_							(    self				:Tuple							)->							"tf.distribute.Strategy":
					requires_backends(self						,	["tf"]							)
					return self._setup_strategy
	@property
	def 					UpperCAmelCase_							(    self				:Optional[Any]							)->							Union[str, Any]:
					requires_backends(self						,	["tf"]							)
					return tf.config.list_physical_devices("GPU"							)
	@property
	def 					UpperCAmelCase_							(    self				:str							)->							int:
					requires_backends(self						,	["tf"]							)
					if self.cuda:
									return len(self.gpu_list							)
					return 0



	@property
	def 					UpperCAmelCase_							(    self				:int							)->							bool:
					return self.n_gpu > 0










'''simple docstring'''

import qiskit





def 						UpperCamelCase    (							_lowerCamelCase : int						,	_lowerCamelCase : int	):
    A__    =      qiskit.Aer.get_backend("aer_simulator"	)

    # Create a Quantum Circuit acting on the q register
    A__    =      qiskit.QuantumCircuit(_lowerCamelCase						,	_lowerCamelCase	)

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

    # Execute the circuit on the simulator
    A__    =      qiskit.execute(_lowerCamelCase						,	_lowerCamelCase						,	shots=10_00	)

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


if __name__ == "__main__":
  print(f"""Total count for various states are: {single_qubit_measure(1, 1)}""")



