


import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, slow, torch_device

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin







class 					__lowercase					(       a_ ,       a_ ,       unittest.TestCase     ):



		"""simple docstring"""

		UpperCamelCase    :				List[str] 					=		UNetaDModel
		UpperCamelCase    :				Union[str, Any] 					=		"sample"







		@property
		def 				__A      (   self  )     ->   Optional[Any]:







					'''simple docstring'''







					lowerCamelCase								=     4
					lowerCamelCase								=     14
					lowerCamelCase								=     16

					lowerCamelCase								=     floats_tensor((batch_size, num_features, seq_len)  ).to(A  )
					lowerCamelCase								=     torch.tensor([10] * batch_size  ).to(A  )

					return {"sample": noise, "timestep": time_step}







		@property
		def 				__A      (   self  )     ->   Optional[Any]:







					'''simple docstring'''







					return (4, 14, 16)







		@property
		def 				__A      (   self  )     ->   int:







					'''simple docstring'''







					return (4, 14, 16)







		def 				__A      (   self  )     ->   Optional[Any]:







					'''simple docstring'''







					pass







		def 				__A      (   self  )     ->   str:







					'''simple docstring'''







					pass







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Any:







					'''simple docstring'''







					super().test_determinism()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Dict:







					'''simple docstring'''







					super().test_outputs_equivalence()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Tuple:







					'''simple docstring'''







					super().test_from_save_pretrained()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   List[Any]:







					'''simple docstring'''







					super().test_from_save_pretrained_variant()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   str:







					'''simple docstring'''







					super().test_model_from_pretrained()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Dict:







					'''simple docstring'''







					super().test_output()







		def 				__A      (   self  )     ->   Tuple:







					'''simple docstring'''







					lowerCamelCase								=     {
					    """block_out_channels""": (32, 64, 1_28, 2_56),
					    """in_channels""": 14,
					    """out_channels""": 14,
					    """time_embedding_type""": """positional""",
					    """use_timestep_embedding""": True,
					    """flip_sin_to_cos""": False,
					    """freq_shift""": 1.0,
					    """out_block_type""": """OutConv1DBlock""",
					    """mid_block_type""": """MidResTemporalBlock1D""",
					    """down_block_types""": ("""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""),
					    """up_block_types""": ("""UpResnetBlock1D""", """UpResnetBlock1D""", """UpResnetBlock1D"""),
					    """act_fn""": """mish""",
					}
					lowerCamelCase								=     self.dummy_input
					return init_dict, inputs_dict







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   str:







					'''simple docstring'''







					lowerCamelCase		,		lowerCamelCase								=     UNetaDModel.from_pretrained(
					    """bglick13/hopper-medium-v2-value-function-hor32"""		,			output_loading_info=A		,			subfolder="""unet"""  )
					self.assertIsNotNone(A  )
					self.assertEqual(len(loading_info["""missing_keys"""]  )		,			0  )

					model.to(A  )
					lowerCamelCase								=     model(**self.dummy_input  )

					assert image is not None, "Make sure output is not None"







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Dict:







					'''simple docstring'''







					lowerCamelCase								=     UNetaDModel.from_pretrained("""bglick13/hopper-medium-v2-value-function-hor32"""		,			subfolder="""unet"""  )
					torch.manual_seed(0  )
					if torch.cuda.is_available():
								torch.cuda.manual_seed_all(0  )

					lowerCamelCase								=     model.config.in_channels
					lowerCamelCase								=     16
					lowerCamelCase								=     torch.randn((1, seq_len, num_features)  ).permute(
					    0		,			2		,			1  )  # match original, we can update values and remove
					lowerCamelCase								=     torch.full((num_features,)		,			0  )

					with torch.no_grad():
								lowerCamelCase								=     model(A		,			A  ).sample.permute(0		,			2		,			1  )

					lowerCamelCase								=     output[0, -3:, -3:].flatten()
					# fmt: off
					lowerCamelCase								=     torch.tensor([-2.137172, 1.1426016, 0.3688687, -0.766922, 0.7303146, 0.11038864, -0.4760633, 0.13270172, 0.02591348]  )
					# fmt: on
					self.assertTrue(torch.allclose(A		,			A		,			rtol=1e-3  )  )







		def 				__A      (   self  )     ->   str:







					'''simple docstring'''







					pass







		@slow
		def 				__A      (   self  )     ->   Optional[int]:







					'''simple docstring'''







					lowerCamelCase								=     """harmonai/maestro-150k"""
					lowerCamelCase								=     UNetaDModel.from_pretrained(A		,			subfolder="""unet"""  )
					model.to(A  )

					lowerCamelCase								=     6_55_36
					lowerCamelCase								=     torch.sin(torch.arange(A  )[None, None, :].repeat(1		,			2		,			1  )  ).to(A  )
					lowerCamelCase								=     torch.tensor([1]  ).to(A  )

					with torch.no_grad():
								lowerCamelCase								=     model(A		,			A  ).sample

					lowerCamelCase								=     output.abs().sum()
					lowerCamelCase								=     output.abs().max()

					assert (output_sum - 224.0896).abs() < 0.5
					assert (output_max - 0.0607).abs() < 4e-4







class 					__lowercase					(       a_ ,       a_ ,       unittest.TestCase     ):



		"""simple docstring"""

		UpperCamelCase    :				Tuple 					=		UNetaDModel
		UpperCamelCase    :				Dict 					=		"sample"







		@property
		def 				__A      (   self  )     ->   Optional[int]:







					'''simple docstring'''







					lowerCamelCase								=     4
					lowerCamelCase								=     14
					lowerCamelCase								=     16

					lowerCamelCase								=     floats_tensor((batch_size, num_features, seq_len)  ).to(A  )
					lowerCamelCase								=     torch.tensor([10] * batch_size  ).to(A  )

					return {"sample": noise, "timestep": time_step}







		@property
		def 				__A      (   self  )     ->   List[str]:







					'''simple docstring'''







					return (4, 14, 16)







		@property
		def 				__A      (   self  )     ->   Dict:







					'''simple docstring'''







					return (4, 14, 1)







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Tuple:







					'''simple docstring'''







					super().test_determinism()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Optional[int]:







					'''simple docstring'''







					super().test_outputs_equivalence()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   int:







					'''simple docstring'''







					super().test_from_save_pretrained()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Optional[int]:







					'''simple docstring'''







					super().test_from_save_pretrained_variant()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Optional[int]:







					'''simple docstring'''







					super().test_model_from_pretrained()







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Dict:







					'''simple docstring'''







					lowerCamelCase		,		lowerCamelCase								=     self.prepare_init_args_and_inputs_for_common()
					lowerCamelCase								=     self.model_class(**A  )
					model.to(A  )
					model.eval()

					with torch.no_grad():
								lowerCamelCase								=     model(**A  )

								if isinstance(A		,			A  ):
											lowerCamelCase								=     output.sample

					self.assertIsNotNone(A  )
					lowerCamelCase								=     torch.Size((inputs_dict["""sample"""].shape[0], 1)  )
					self.assertEqual(output.shape		,			A		,			"""Input and output shapes do not match"""  )







		def 				__A      (   self  )     ->   Optional[int]:







					'''simple docstring'''







					pass







		def 				__A      (   self  )     ->   Optional[int]:







					'''simple docstring'''







					pass







		def 				__A      (   self  )     ->   Dict:







					'''simple docstring'''







					lowerCamelCase								=     {
					    """in_channels""": 14,
					    """out_channels""": 14,
					    """down_block_types""": ["""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""],
					    """up_block_types""": [],
					    """out_block_type""": """ValueFunction""",
					    """mid_block_type""": """ValueFunctionMidBlock1D""",
					    """block_out_channels""": [32, 64, 1_28, 2_56],
					    """layers_per_block""": 1,
					    """downsample_each_block""": True,
					    """use_timestep_embedding""": True,
					    """freq_shift""": 1.0,
					    """flip_sin_to_cos""": False,
					    """time_embedding_type""": """positional""",
					    """act_fn""": """mish""",
					}
					lowerCamelCase								=     self.dummy_input
					return init_dict, inputs_dict







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Optional[Any]:







					'''simple docstring'''







					lowerCamelCase		,		lowerCamelCase								=     UNetaDModel.from_pretrained(
					    """bglick13/hopper-medium-v2-value-function-hor32"""		,			output_loading_info=A		,			subfolder="""value_function"""  )
					self.assertIsNotNone(A  )
					self.assertEqual(len(vf_loading_info["""missing_keys"""]  )		,			0  )

					value_function.to(A  )
					lowerCamelCase								=     value_function(**self.dummy_input  )

					assert image is not None, "Make sure output is not None"







		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
		def 				__A      (   self  )     ->   Any:







					'''simple docstring'''







					lowerCamelCase		,		lowerCamelCase								=     UNetaDModel.from_pretrained(
					    """bglick13/hopper-medium-v2-value-function-hor32"""		,			output_loading_info=A		,			subfolder="""value_function"""  )
					torch.manual_seed(0  )
					if torch.cuda.is_available():
								torch.cuda.manual_seed_all(0  )

					lowerCamelCase								=     value_function.config.in_channels
					lowerCamelCase								=     14
					lowerCamelCase								=     torch.randn((1, seq_len, num_features)  ).permute(
					    0		,			2		,			1  )  # match original, we can update values and remove
					lowerCamelCase								=     torch.full((num_features,)		,			0  )

					with torch.no_grad():
								lowerCamelCase								=     value_function(A		,			A  ).sample

					# fmt: off
					lowerCamelCase								=     torch.tensor([165.25] * seq_len  )
					# fmt: on
					self.assertTrue(torch.allclose(A		,			A		,			rtol=1e-3  )  )







		def 				__A      (   self  )     ->   int:







					'''simple docstring'''







					pass





import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute






def   __lowerCamelCase	(       lowerCamelCase__		:	int = 1     ,       lowerCamelCase__		:	int = 1			):





			'''simple docstring'''




			if isinstance(lowerCamelCase__     ,       lowerCamelCase__			) or isinstance(lowerCamelCase__     ,       lowerCamelCase__			):
						raise TypeError("""inputs must be integers."""			)
			if (bit_a < 0) or (bit_a < 0):
						raise ValueError("""inputs must be positive."""			)
			if (math.floor(lowerCamelCase__			) != bit_a) or (math.floor(lowerCamelCase__			) != bit_a):
						raise ValueError("""inputs must be exact integers."""			)
			if (bit_a > 1) or (bit_a > 1):
						raise ValueError("""inputs must be less or equal to 1."""			)

			# build registers
			lowerCamelCase								=     QuantumRegister(2     ,       """qr"""			)
			lowerCamelCase								=     ClassicalRegister(2     ,       """cr"""			)

			lowerCamelCase								=     QuantumCircuit(lowerCamelCase__     ,       lowerCamelCase__			)

			# entanglement the qubits
			quantum_circuit.h(1			)
			quantum_circuit.cx(1     ,       0			)

			# send the information
			lowerCamelCase								=     str(lowerCamelCase__			) + str(lowerCamelCase__			)

			if c_information == "11":
						quantum_circuit.x(1			)
						quantum_circuit.z(1			)
			elif c_information == "10":
						quantum_circuit.z(1			)
			elif c_information == "01":
						quantum_circuit.x(1			)
			else:
						quantum_circuit.i(1			)

			# unentangled the circuit
			quantum_circuit.cx(1     ,       0			)
			quantum_circuit.h(1			)

			# measure the circuit
			quantum_circuit.measure(lowerCamelCase__     ,       lowerCamelCase__			)

			lowerCamelCase								=     Aer.get_backend("""aer_simulator"""			)
			lowerCamelCase								=     execute(lowerCamelCase__     ,       lowerCamelCase__     ,       shots=1000			)

			return job.result().get_counts(lowerCamelCase__			)


if __name__ == "__main__":
		print(f"""Counts for classical state send: {superdense_coding(1,1)}""")

