




'''simple docstring'''







import argparse
import json

import torch

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





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_=1	):
    if n_shave_prefix_segments >= 0:
        return ".".join(path.split("."	)[n_shave_prefix_segments:]	)
    else:
        return ".".join(path.split("."	)[:n_shave_prefix_segments]	)





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_=0	):
    UpperCamelCase__      =			[]
    for old_item in old_list:
        UpperCamelCase__      =			old_item
        UpperCamelCase__      =			new_item.replace("block."					,  "resnets."	)
        UpperCamelCase__      =			new_item.replace("conv_shorcut"					,  "conv1"	)
        UpperCamelCase__      =			new_item.replace("in_shortcut"					,  "conv_shortcut"	)
        UpperCamelCase__      =			new_item.replace("temb_proj"					,  "time_emb_proj"	)

        UpperCamelCase__      =			shave_segments(lowerCAmelCase_					,  n_shave_prefix_segments=lowerCAmelCase_	)

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

    return mapping





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_=0					,  lowerCAmelCase_=False	):
    UpperCamelCase__      =			[]
    for old_item in old_list:
        UpperCamelCase__      =			old_item

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

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

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

    return mapping





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_=None					,  lowerCAmelCase_=None					,  lowerCAmelCase_=None	):
    assert isinstance(lowerCAmelCase_					,  lowerCAmelCase_	), "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():
            UpperCamelCase__      =			old_checkpoint[path]
            UpperCamelCase__      =			old_tensor.shape[0] // 3

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

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

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

            UpperCamelCase__      =			query.reshape(lowerCAmelCase_	).squeeze()
            UpperCamelCase__      =			key.reshape(lowerCAmelCase_	).squeeze()
            UpperCamelCase__      =			value.reshape(lowerCAmelCase_	).squeeze()

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

        if attention_paths_to_split is not None and new_path in attention_paths_to_split:
            continue

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

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

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





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_	):
    UpperCamelCase__      =			{}

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

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

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

    UpperCamelCase__      =			len({".".join(layer.split("."	)[:2]	) for layer in checkpoint if "down" in layer}	)
    UpperCamelCase__      =			{
        layer_id: [key for key in checkpoint if F'down.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)
    }

    UpperCamelCase__      =			len({".".join(layer.split("."	)[:2]	) for layer in checkpoint if "up" in layer}	)
    UpperCamelCase__      =			{layer_id: [key for key in checkpoint if F'up.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)}

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

        if any("downsample" in layer for layer in down_blocks[i]	):
            UpperCamelCase__      =			checkpoint[
                F'down.{i}.downsample.op.weight'
            ]
            UpperCamelCase__      =			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]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  2	).split("."	)[:2]	) for layer in down_blocks[i] if "block" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in down_blocks[i] if F'block.{layer_id}' in key]
                for layer_id in range(lowerCAmelCase_	)
            }

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

        if any("attn" in layer for layer in down_blocks[i]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  2	).split("."	)[:2]	) for layer in down_blocks[i] if "attn" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in down_blocks[i] if F'attn.{layer_id}' in key]
                for layer_id in range(lowerCAmelCase_	)
            }

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

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

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

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

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

    for i in range(lowerCAmelCase_	):
        UpperCamelCase__      =			num_up_blocks - 1 - i

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

        if any("block" in layer for layer in up_blocks[i]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  2	).split("."	)[:2]	) for layer in up_blocks[i] if "block" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in up_blocks[i] if F'block.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)
            }

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

        if any("attn" in layer for layer in up_blocks[i]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  2	).split("."	)[:2]	) for layer in up_blocks[i] if "attn" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in up_blocks[i] if F'attn.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)
            }

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

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





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_	):
    UpperCamelCase__      =			{}

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

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

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

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

    UpperCamelCase__      =			len({".".join(layer.split("."	)[:3]	) for layer in checkpoint if "down" in layer}	)
    UpperCamelCase__      =			{
        layer_id: [key for key in checkpoint if F'down.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)
    }

    UpperCamelCase__      =			len({".".join(layer.split("."	)[:3]	) for layer in checkpoint if "up" in layer}	)
    UpperCamelCase__      =			{layer_id: [key for key in checkpoint if F'up.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)}

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

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

        if any("block" in layer for layer in down_blocks[i]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  3	).split("."	)[:3]	) for layer in down_blocks[i] if "block" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in down_blocks[i] if F'block.{layer_id}' in key]
                for layer_id in range(lowerCAmelCase_	)
            }

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

        if any("attn" in layer for layer in down_blocks[i]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  3	).split("."	)[:3]	) for layer in down_blocks[i] if "attn" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in down_blocks[i] if F'attn.{layer_id}' in key]
                for layer_id in range(lowerCAmelCase_	)
            }

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

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

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

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

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

    for i in range(lowerCAmelCase_	):
        UpperCamelCase__      =			num_up_blocks - 1 - i

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

        if any("block" in layer for layer in up_blocks[i]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  3	).split("."	)[:3]	) for layer in up_blocks[i] if "block" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in up_blocks[i] if F'block.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)
            }

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

        if any("attn" in layer for layer in up_blocks[i]	):
            UpperCamelCase__      =			len(
                {".".join(shave_segments(lowerCAmelCase_					,  3	).split("."	)[:3]	) for layer in up_blocks[i] if "attn" in layer}	)
            UpperCamelCase__      =			{
                layer_id: [key for key in up_blocks[i] if F'attn.{layer_id}' in key] for layer_id in range(lowerCAmelCase_	)
            }

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

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

    return new_checkpoint


if __name__ == "__main__":
      lowercase__     :  int    					=			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.')

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

      with open(args.config_file) as f:
            lowercase__     :  Union[str, Any]    					=			json.loads(f.read())

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

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

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

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

            lowercase__     :  int    					=			DDPMPipeline(unet=model, scheduler=scheduler)
            pipe.save_pretrained(args.dump_path)









'''simple docstring'''







import unittest

from transformers import load_tool
from transformers.tools.agent_types import AGENT_TYPE_MAPPING

from .test_tools_common import ToolTesterMixin, output_types

class       lowerCamelCase_							(	unittest.TestCase					,    lowerCAmelCase_  ):






   '''simple docstring'''

   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			load_tool("translation" )
       self.tool.setup()
       UpperCamelCase__      =			load_tool("translation"     ,						remote=__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.tool("Hey, what's up?"     ,						src_lang="English"     ,						tgt_lang="French" )
       self.assertEqual(__UpperCamelCase     ,						"- Hé, comment ça va?" )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.remote_tool("Hey, what's up?"     ,						src_lang="English"     ,						tgt_lang="French" )
       self.assertEqual(__UpperCamelCase     ,						"- Hé, comment ça va?" )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.tool(text="Hey, what's up?"     ,						src_lang="English"     ,						tgt_lang="French" )
       self.assertEqual(__UpperCamelCase     ,						"- Hé, comment ça va?" )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.remote_tool(text="Hey, what's up?"     ,						src_lang="English"     ,						tgt_lang="French" )
       self.assertEqual(__UpperCamelCase     ,						"- Hé, comment ça va?" )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			["Hey, what's up?", "English", "Spanish"]
       UpperCamelCase__      =			self.tool(*__UpperCamelCase )

       # There is a single output
       if len(self.tool.outputs ) == 1:
           UpperCamelCase__      =			[outputs]

       self.assertListEqual(output_types(__UpperCamelCase )     ,						self.tool.outputs )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			["Hey, what's up?", "English", "Spanish"]
       UpperCamelCase__      =			self.tool(*__UpperCamelCase )

       if not isinstance(__UpperCamelCase     ,						__UpperCamelCase ):
           UpperCamelCase__      =			[outputs]

       self.assertEqual(len(__UpperCamelCase )     ,						len(self.tool.outputs ) )

       for output, output_type in zip(__UpperCamelCase     ,						self.tool.outputs ):
           UpperCamelCase__      =			AGENT_TYPE_MAPPING[output_type]
           self.assertTrue(isinstance(__UpperCamelCase     ,						__UpperCamelCase ) )







   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			["Hey, what's up?", "English", "Spanish"]

       UpperCamelCase__      =			[]

       for _input, input_type in zip(__UpperCamelCase     ,						self.tool.inputs ):
           if isinstance(__UpperCamelCase     ,						__UpperCamelCase ):
               _inputs.append([AGENT_TYPE_MAPPING[_input_type](_input ) for _input_type in input_type] )
           else:
               _inputs.append(AGENT_TYPE_MAPPING[input_type](_input ) )

        # Should not raise an error
       UpperCamelCase__      =			self.tool(*__UpperCamelCase )

       if not isinstance(__UpperCamelCase     ,						__UpperCamelCase ):
           UpperCamelCase__      =			[outputs]

       self.assertEqual(len(__UpperCamelCase )     ,						len(self.tool.outputs ) )




