





'''simple docstring'''


import argparse
import json

import torch

from diffusers import AutoencoderKL, DDPMPipeline, DDPMScheduler, UNetaDModel, VQModel




def    __a (     UpperCAmelCase       ,			UpperCAmelCase=1    )      ->int:



	"""simple docstring"""







	if n_shave_prefix_segments >= 0:
		return ".".join(path.split("""."""    )[n_shave_prefix_segments:]    )
	else:
		return ".".join(path.split("""."""    )[:n_shave_prefix_segments]    )




def    __a (     UpperCAmelCase       ,			UpperCAmelCase=0    )      ->str:



	"""simple docstring"""







	A							  =      []
	for old_item in old_list:
		A							  =      old_item
		A							  =      new_item.replace("""block."""       ,			"""resnets."""    )
		A							  =      new_item.replace("""conv_shorcut"""       ,			"""conv1"""    )
		A							  =      new_item.replace("""in_shortcut"""       ,			"""conv_shortcut"""    )
		A							  =      new_item.replace("""temb_proj"""       ,			"""time_emb_proj"""    )

		A							  =      shave_segments(UpperCAmelCase       ,			n_shave_prefix_segments=UpperCAmelCase    )

		mapping.append({"""old""": old_item, """new""": new_item}    )

	return mapping




def    __a (     UpperCAmelCase       ,			UpperCAmelCase=0       ,			UpperCAmelCase=False    )      ->Optional[Any]:



	"""simple docstring"""







	A							  =      []
	for old_item in old_list:
		A							  =      old_item

		# In `model.mid`, the layer is called `attn`.
		if not in_mid:
			A							  =      new_item.replace("""attn"""       ,			"""attentions"""    )
		A							  =      new_item.replace(""".k."""       ,			""".key."""    )
		A							  =      new_item.replace(""".v."""       ,			""".value."""    )
		A							  =      new_item.replace(""".q."""       ,			""".query."""    )

		A							  =      new_item.replace("""proj_out"""       ,			"""proj_attn"""    )
		A							  =      new_item.replace("""norm"""       ,			"""group_norm"""    )

		A							  =      shave_segments(UpperCAmelCase       ,			n_shave_prefix_segments=UpperCAmelCase    )
		mapping.append({"""old""": old_item, """new""": new_item}    )

	return mapping




def    __a (     UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase=None       ,			UpperCAmelCase=None       ,			UpperCAmelCase=None    )      ->Dict:



	"""simple docstring"""







	assert isinstance(UpperCAmelCase       ,			UpperCAmelCase    ), "Paths should be a list of dicts containing 'old' and 'new' keys."

	if attention_paths_to_split is not None:
		if config is None:
			raise ValueError("""Please specify the config if setting 'attention_paths_to_split' to 'True'."""    )

		for path, path_map in attention_paths_to_split.items():
			A							  =      old_checkpoint[path]
			A							  =      old_tensor.shape[0] // 3

			A							  =      (-1, channels) if len(old_tensor.shape    ) == 3 else (-1)

			A							  =      old_tensor.shape[0] // config.get("""num_head_channels"""       ,			1    ) // 3

			A							  =      old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]    )
			A  ,    A  ,    A							  =      old_tensor.split(channels // num_heads       ,			dim=1    )

			A							  =      query.reshape(UpperCAmelCase    ).squeeze()
			A							  =      key.reshape(UpperCAmelCase    ).squeeze()
			A							  =      value.reshape(UpperCAmelCase    ).squeeze()

	for path in paths:
		A							  =      path["""new"""]

		if attention_paths_to_split is not None and new_path in attention_paths_to_split:
			continue

		A							  =      new_path.replace("""down."""       ,			"""down_blocks."""    )
		A							  =      new_path.replace("""up."""       ,			"""up_blocks."""    )

		if additional_replacements is not None:
			for replacement in additional_replacements:
				A							  =      new_path.replace(replacement["""old"""]       ,			replacement["""new"""]    )

		if "attentions" in new_path:
			A							  =      old_checkpoint[path["""old"""]].squeeze()
		else:
			A							  =      old_checkpoint[path["""old"""]]




def    __a (     UpperCAmelCase       ,			UpperCAmelCase    )      ->Optional[Any]:



	"""simple docstring"""







	A							  =      {}

	A							  =      checkpoint["""temb.dense.0.weight"""]
	A							  =      checkpoint["""temb.dense.0.bias"""]
	A							  =      checkpoint["""temb.dense.1.weight"""]
	A							  =      checkpoint["""temb.dense.1.bias"""]

	A							  =      checkpoint["""norm_out.weight"""]
	A							  =      checkpoint["""norm_out.bias"""]

	A							  =      checkpoint["""conv_in.weight"""]
	A							  =      checkpoint["""conv_in.bias"""]
	A							  =      checkpoint["""conv_out.weight"""]
	A							  =      checkpoint["""conv_out.bias"""]

	A							  =      len({""".""".join(layer.split("""."""    )[:2]    ) for layer in checkpoint if """down""" in layer}    )
	A							  =      {
	    layer_id: [key for key in checkpoint if f"""down.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
	}

	A							  =      len({""".""".join(layer.split("""."""    )[:2]    ) for layer in checkpoint if """up""" in layer}    )
	A							  =      {layer_id: [key for key in checkpoint if f"""up.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )}

	for i in range(UpperCAmelCase    ):
		A							  =      (i - 1) // (config["""layers_per_block"""] + 1)

		if any("""downsample""" in layer for layer in down_blocks[i]    ):
			A							  =      checkpoint[
			    f"""down.{i}.downsample.op.weight"""
			]
			A							  =      checkpoint[f"""down.{i}.downsample.op.bias"""]
		#            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.weight'] = checkpoint[f'down.{i}.downsample.conv.weight']
		#            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.bias'] = checkpoint[f'down.{i}.downsample.conv.bias']

		if any("""block""" in layer for layer in down_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in down_blocks[i] if """block""" in layer}    )
			A							  =      {
			    layer_id: [key for key in down_blocks[i] if f"""block.{layer_id}""" in key]
			    for layer_id in range(UpperCAmelCase    )
			}

			if num_blocks > 0:
				for j in range(config["""layers_per_block"""]    ):
					A							  =      renew_resnet_paths(blocks[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase    )

		if any("""attn""" in layer for layer in down_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in down_blocks[i] if """attn""" in layer}    )
			A							  =      {
			    layer_id: [key for key in down_blocks[i] if f"""attn.{layer_id}""" in key]
			    for layer_id in range(UpperCAmelCase    )
			}

			if num_attn > 0:
				for j in range(config["""layers_per_block"""]    ):
					A							  =      renew_attention_paths(attns[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			config=UpperCAmelCase    )

	A							  =      [key for key in checkpoint if """mid.block_1""" in key]
	A							  =      [key for key in checkpoint if """mid.block_2""" in key]
	A							  =      [key for key in checkpoint if """mid.attn_1""" in key]

	# Mid new 2
	A							  =      renew_resnet_paths(UpperCAmelCase    )
	assign_to_checkpoint(
	    UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_1""", """new""": """resnets.0"""}]       ,			)

	A							  =      renew_resnet_paths(UpperCAmelCase    )
	assign_to_checkpoint(
	    UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_2""", """new""": """resnets.1"""}]       ,			)

	A							  =      renew_attention_paths(UpperCAmelCase       ,			in_mid=UpperCAmelCase    )
	assign_to_checkpoint(
	    UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """attn_1""", """new""": """attentions.0"""}]       ,			)

	for i in range(UpperCAmelCase    ):
		A							  =      num_up_blocks - 1 - i

		if any("""upsample""" in layer for layer in up_blocks[i]    ):
			A							  =      checkpoint[
			    f"""up.{i}.upsample.conv.weight"""
			]
			A							  =      checkpoint[f"""up.{i}.upsample.conv.bias"""]

		if any("""block""" in layer for layer in up_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in up_blocks[i] if """block""" in layer}    )
			A							  =      {
			    layer_id: [key for key in up_blocks[i] if f"""block.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
			}

			if num_blocks > 0:
				for j in range(config["""layers_per_block"""] + 1    ):
					A							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
					A							  =      renew_resnet_paths(blocks[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[replace_indices]    )

		if any("""attn""" in layer for layer in up_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in up_blocks[i] if """attn""" in layer}    )
			A							  =      {
			    layer_id: [key for key in up_blocks[i] if f"""attn.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
			}

			if num_attn > 0:
				for j in range(config["""layers_per_block"""] + 1    ):
					A							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
					A							  =      renew_attention_paths(attns[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[replace_indices]    )

	A							  =      {k.replace("""mid_new_2"""       ,			"""mid_block"""    ): v for k, v in new_checkpoint.items()}
	return new_checkpoint




def    __a (     UpperCAmelCase       ,			UpperCAmelCase    )      ->Dict:



	"""simple docstring"""







	A							  =      {}

	A							  =      checkpoint["""encoder.norm_out.weight"""]
	A							  =      checkpoint["""encoder.norm_out.bias"""]

	A							  =      checkpoint["""encoder.conv_in.weight"""]
	A							  =      checkpoint["""encoder.conv_in.bias"""]
	A							  =      checkpoint["""encoder.conv_out.weight"""]
	A							  =      checkpoint["""encoder.conv_out.bias"""]

	A							  =      checkpoint["""decoder.norm_out.weight"""]
	A							  =      checkpoint["""decoder.norm_out.bias"""]

	A							  =      checkpoint["""decoder.conv_in.weight"""]
	A							  =      checkpoint["""decoder.conv_in.bias"""]
	A							  =      checkpoint["""decoder.conv_out.weight"""]
	A							  =      checkpoint["""decoder.conv_out.bias"""]

	A							  =      len({""".""".join(layer.split("""."""    )[:3]    ) for layer in checkpoint if """down""" in layer}    )
	A							  =      {
	    layer_id: [key for key in checkpoint if f"""down.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
	}

	A							  =      len({""".""".join(layer.split("""."""    )[:3]    ) for layer in checkpoint if """up""" in layer}    )
	A							  =      {layer_id: [key for key in checkpoint if f"""up.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )}

	for i in range(UpperCAmelCase    ):
		A							  =      (i - 1) // (config["""layers_per_block"""] + 1)

		if any("""downsample""" in layer for layer in down_blocks[i]    ):
			A							  =      checkpoint[
			    f"""encoder.down.{i}.downsample.conv.weight"""
			]
			A							  =      checkpoint[
			    f"""encoder.down.{i}.downsample.conv.bias"""
			]

		if any("""block""" in layer for layer in down_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in down_blocks[i] if """block""" in layer}    )
			A							  =      {
			    layer_id: [key for key in down_blocks[i] if f"""block.{layer_id}""" in key]
			    for layer_id in range(UpperCAmelCase    )
			}

			if num_blocks > 0:
				for j in range(config["""layers_per_block"""]    ):
					A							  =      renew_resnet_paths(blocks[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase    )

		if any("""attn""" in layer for layer in down_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in down_blocks[i] if """attn""" in layer}    )
			A							  =      {
			    layer_id: [key for key in down_blocks[i] if f"""attn.{layer_id}""" in key]
			    for layer_id in range(UpperCAmelCase    )
			}

			if num_attn > 0:
				for j in range(config["""layers_per_block"""]    ):
					A							  =      renew_attention_paths(attns[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			config=UpperCAmelCase    )

	A							  =      [key for key in checkpoint if """mid.block_1""" in key]
	A							  =      [key for key in checkpoint if """mid.block_2""" in key]
	A							  =      [key for key in checkpoint if """mid.attn_1""" in key]

	# Mid new 2
	A							  =      renew_resnet_paths(UpperCAmelCase    )
	assign_to_checkpoint(
	    UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_1""", """new""": """resnets.0"""}]       ,			)

	A							  =      renew_resnet_paths(UpperCAmelCase    )
	assign_to_checkpoint(
	    UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_2""", """new""": """resnets.1"""}]       ,			)

	A							  =      renew_attention_paths(UpperCAmelCase       ,			in_mid=UpperCAmelCase    )
	assign_to_checkpoint(
	    UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """attn_1""", """new""": """attentions.0"""}]       ,			)

	for i in range(UpperCAmelCase    ):
		A							  =      num_up_blocks - 1 - i

		if any("""upsample""" in layer for layer in up_blocks[i]    ):
			A							  =      checkpoint[
			    f"""decoder.up.{i}.upsample.conv.weight"""
			]
			A							  =      checkpoint[
			    f"""decoder.up.{i}.upsample.conv.bias"""
			]

		if any("""block""" in layer for layer in up_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in up_blocks[i] if """block""" in layer}    )
			A							  =      {
			    layer_id: [key for key in up_blocks[i] if f"""block.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
			}

			if num_blocks > 0:
				for j in range(config["""layers_per_block"""] + 1    ):
					A							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
					A							  =      renew_resnet_paths(blocks[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[replace_indices]    )

		if any("""attn""" in layer for layer in up_blocks[i]    ):
			A							  =      len(
			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in up_blocks[i] if """attn""" in layer}    )
			A							  =      {
			    layer_id: [key for key in up_blocks[i] if f"""attn.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
			}

			if num_attn > 0:
				for j in range(config["""layers_per_block"""] + 1    ):
					A							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
					A							  =      renew_attention_paths(attns[j]    )
					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[replace_indices]    )

	A							  =      {k.replace("""mid_new_2"""       ,			"""mid_block"""    ): v for k, v in new_checkpoint.items()}
	A							  =      checkpoint["""quant_conv.weight"""]
	A							  =      checkpoint["""quant_conv.bias"""]
	if "quantize.embedding.weight" in checkpoint:
		A							  =      checkpoint["""quantize.embedding.weight"""]
	A							  =      checkpoint["""post_quant_conv.weight"""]
	A							  =      checkpoint["""post_quant_conv.bias"""]

	return new_checkpoint


if __name__ == "__main__":
				_lowerCamelCase				:	List[str]				    =       argparse.ArgumentParser()

				parser.add_argument(
				    '--checkpoint_path', default=None, type=str, required=True, help='Path to the checkpoint to convert.'
				)

				parser.add_argument(
				    '--config_file',
				    default=None,
				    type=str,
				    required=True,
				    help='The config json file corresponding to the architecture.',
				)

				parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')

				_lowerCamelCase				:	List[Any]				    =       parser.parse_args()
				_lowerCamelCase				:	Optional[Any]				    =       torch.load(args.checkpoint_path)

				with open(args.config_file) as f:
								_lowerCamelCase				:	str				    =       json.loads(f.read())

				# unet case
				_lowerCamelCase				:	List[str]				    =       {key.split('.')[0] for key in checkpoint.keys()}
				if "encoder" in key_prefix_set and "decoder" in key_prefix_set:
								_lowerCamelCase				:	Dict				    =       convert_vq_autoenc_checkpoint(checkpoint, config)
				else:
								_lowerCamelCase				:	Optional[int]				    =       convert_ddpm_checkpoint(checkpoint, config)

				if "ddpm" in config:
								del config["ddpm"]

				if config["_class_name"] == "VQModel":
								_lowerCamelCase				:	List[str]				    =       VQModel(**config)
								model.load_state_dict(converted_checkpoint)
								model.save_pretrained(args.dump_path)
				elif config["_class_name"] == "AutoencoderKL":
								_lowerCamelCase				:	Optional[int]				    =       AutoencoderKL(**config)
								model.load_state_dict(converted_checkpoint)
								model.save_pretrained(args.dump_path)
				else:
								_lowerCamelCase				:	List[str]				    =       UNetaDModel(**config)
								model.load_state_dict(converted_checkpoint)

								_lowerCamelCase				:	Optional[Any]				    =       DDPMScheduler.from_config('/'.join(args.checkpoint_path.split('/')[:-1]))

								_lowerCamelCase				:	List[Any]				    =       DDPMPipeline(unet=model, scheduler=scheduler)
								pipe.save_pretrained(args.dump_path)








'''simple docstring'''


import tempfile
import unittest

import numpy as np
import torch

from diffusers import DiffusionPipeline
from diffusers.models.attention_processor import Attention, AttnAddedKVProcessor



class 							__UpperCAmelCase  (       unittest.TestCase						):







		'''simple docstring'''







		def        A     (self						:      Optional[int]      ,      _lowerCAmelCase						:      bool = False      ):
			A							  =      10

			if only_cross_attention:
				A							  =      12
			else:
				# when only cross attention is not set, the cross attention dim must be the same as the query dim
				A							  =      query_dim

			return {
			    "query_dim": query_dim,
			    "cross_attention_dim": cross_attention_dim,
			    "heads": 2,
			    "dim_head": 4,
			    "added_kv_proj_dim": 6,
			    "norm_num_groups": 1,
			    "only_cross_attention": only_cross_attention,
			    "processor": AttnAddedKVProcessor(),
			}







		def        A     (self						:      Optional[int]      ,      _lowerCAmelCase						:      Dict      ,      _lowerCAmelCase						:      Any      ):
			A							  =      2

			A							  =      torch.rand(_lowerCAmelCase      ,      _lowerCAmelCase      ,      3      ,      2      )
			A							  =      torch.rand(_lowerCAmelCase      ,      4      ,      _lowerCAmelCase      )
			A							  =      None

			return {
			    "hidden_states": hidden_states,
			    "encoder_hidden_states": encoder_hidden_states,
			    "attention_mask": attention_mask,
			}







		def        A     (self						:      Optional[Any]      ):
			# self and cross attention

			torch.manual_seed(0      )

			A							  =      self.get_constructor_arguments(only_cross_attention=_lowerCAmelCase      )
			A							  =      Attention(**_lowerCAmelCase      )

			self.assertTrue(attn.to_k is not None      )
			self.assertTrue(attn.to_v is not None      )

			A							  =      self.get_forward_arguments(
			    query_dim=constructor_args["""query_dim"""]      ,      added_kv_proj_dim=constructor_args["""added_kv_proj_dim"""]      )

			A							  =      attn(**_lowerCAmelCase      )

			# only self attention

			torch.manual_seed(0      )

			A							  =      self.get_constructor_arguments(only_cross_attention=_lowerCAmelCase      )
			A							  =      Attention(**_lowerCAmelCase      )

			self.assertTrue(attn.to_k is None      )
			self.assertTrue(attn.to_v is None      )

			A							  =      self.get_forward_arguments(
			    query_dim=constructor_args["""query_dim"""]      ,      added_kv_proj_dim=constructor_args["""added_kv_proj_dim"""]      )

			A							  =      attn(**_lowerCAmelCase      )

			self.assertTrue((only_cross_attn_out != self_and_cross_attn_out).all()      )






class 							__UpperCAmelCase  (       unittest.TestCase						):







		'''simple docstring'''







		def        A     (self						:      Any      ):
			A							  =      DiffusionPipeline.from_pretrained("""hf-internal-testing/tiny-stable-diffusion-pipe"""      ,      safety_checker=_lowerCAmelCase      )

			A							  =      pipe(
			    """foo"""      ,      num_inference_steps=2      ,      generator=torch.Generator("""cpu"""      ).manual_seed(0      )      ,      output_type="""np"""      ,      ).images

			# the initial conversion succeeds
			A							  =      DiffusionPipeline.from_pretrained(
			    """hf-internal-testing/tiny-stable-diffusion-pipe"""      ,      device_map="""sequential"""      ,      safety_checker=_lowerCAmelCase      )

			A							  =      pipe(
			    """foo"""      ,      num_inference_steps=2      ,      generator=torch.Generator("""cpu"""      ).manual_seed(0      )      ,      output_type="""np"""      ,      ).images

			with tempfile.TemporaryDirectory() as tmpdir:
				# save the converted model
				pipe.save_pretrained(_lowerCAmelCase      )

				# can also load the converted weights
				A							  =      DiffusionPipeline.from_pretrained(_lowerCAmelCase      ,      device_map="""sequential"""      ,      safety_checker=_lowerCAmelCase      )

			A							  =      pipe(
			    """foo"""      ,      num_inference_steps=2      ,      generator=torch.Generator("""cpu"""      ).manual_seed(0      )      ,      output_type="""np"""      ,      ).images

			self.assertTrue(np.allclose(_lowerCAmelCase      ,      _lowerCAmelCase      ,      atol=1e-5      )      )
			self.assertTrue(np.allclose(_lowerCAmelCase      ,      _lowerCAmelCase      ,      atol=1e-5      )      )

