

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
_UpperCamelCase 			=		logging.get_logger(__name__)







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						List[str]					=					SwinConfig(
          embed_dim=1_9_2   ,	depths=(2, 2, 1_8, 2)   ,	num_heads=(6, 1_2, 2_4, 4_8)   ,	window_size=1_2   ,	out_features=['''stage2''', '''stage3''', '''stage4''']   ,	)

      __lowerCAmelCase					:						Optional[int]					=					DetaConfig(
          backbone_config=SCREAMING_SNAKE_CASE__   ,	num_queries=9_0_0   ,	encoder_ffn_dim=2_0_4_8   ,	decoder_ffn_dim=2_0_4_8   ,	num_feature_levels=5   ,	assign_first_stage=SCREAMING_SNAKE_CASE__   ,	with_box_refine=SCREAMING_SNAKE_CASE__   ,	two_stage=SCREAMING_SNAKE_CASE__   ,	)

      # set labels
      __lowerCAmelCase					:						Optional[int]					=					"""huggingface/label-files"""
      if "o365" in model_name:
            __lowerCAmelCase					:						Dict					=					3_6_6
            __lowerCAmelCase					:						List[str]					=					"""object365-id2label.json"""
      else:
            __lowerCAmelCase					:						str					=					9_1
            __lowerCAmelCase					:						Optional[int]					=					"""coco-detection-id2label.json"""

      __lowerCAmelCase					:						str					=					num_labels
      __lowerCAmelCase					:						Optional[Any]					=					json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__   ,	SCREAMING_SNAKE_CASE__   ,	repo_type='''dataset'''						)						)   ,	'''r'''						)						)
      __lowerCAmelCase					:						Optional[Any]					=					{int(SCREAMING_SNAKE_CASE__						): v for k, v in idalabel.items()}
      __lowerCAmelCase					:						str					=					idalabel
      __lowerCAmelCase					:						Union[str, Any]					=					{v: k for k, v in idalabel.items()}

      return config







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						Tuple					=					[]

      # stem
      # fmt: off
      rename_keys.append(('''backbone.0.body.patch_embed.proj.weight''', '''model.backbone.model.embeddings.patch_embeddings.projection.weight''')						)
      rename_keys.append(('''backbone.0.body.patch_embed.proj.bias''', '''model.backbone.model.embeddings.patch_embeddings.projection.bias''')						)
      rename_keys.append(('''backbone.0.body.patch_embed.norm.weight''', '''model.backbone.model.embeddings.norm.weight''')						)
      rename_keys.append(('''backbone.0.body.patch_embed.norm.bias''', '''model.backbone.model.embeddings.norm.bias''')						)
      # stages
      for i in range(len(config.backbone_config.depths						)						):
            for j in range(config.backbone_config.depths[i]						):
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")						)

            if i < 3:
                  rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.reduction.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""")						)
                  rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.bias""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""")						)

      rename_keys.append(('''backbone.0.body.norm1.weight''', '''model.backbone.model.hidden_states_norms.stage2.weight''')						)
      rename_keys.append(('''backbone.0.body.norm1.bias''', '''model.backbone.model.hidden_states_norms.stage2.bias''')						)
      rename_keys.append(('''backbone.0.body.norm2.weight''', '''model.backbone.model.hidden_states_norms.stage3.weight''')						)
      rename_keys.append(('''backbone.0.body.norm2.bias''', '''model.backbone.model.hidden_states_norms.stage3.bias''')						)
      rename_keys.append(('''backbone.0.body.norm3.weight''', '''model.backbone.model.hidden_states_norms.stage4.weight''')						)
      rename_keys.append(('''backbone.0.body.norm3.bias''', '''model.backbone.model.hidden_states_norms.stage4.bias''')						)

      # transformer encoder
      for i in range(config.encoder_layers						):
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", f"""model.encoder.layers.{i}.self_attn.attention_weights.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", f"""model.encoder.layers.{i}.self_attn.attention_weights.bias""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", f"""model.encoder.layers.{i}.self_attn.value_proj.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", f"""model.encoder.layers.{i}.self_attn.value_proj.bias""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", f"""model.encoder.layers.{i}.self_attn.output_proj.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", f"""model.encoder.layers.{i}.self_attn.output_proj.bias""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.weight""", f"""model.encoder.layers.{i}.self_attn_layer_norm.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.bias""", f"""model.encoder.layers.{i}.self_attn_layer_norm.bias""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.weight""", f"""model.encoder.layers.{i}.fc1.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.bias""", f"""model.encoder.layers.{i}.fc1.bias""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.weight""", f"""model.encoder.layers.{i}.fc2.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.bias""", f"""model.encoder.layers.{i}.fc2.bias""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.weight""", f"""model.encoder.layers.{i}.final_layer_norm.weight""")						)
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.bias""", f"""model.encoder.layers.{i}.final_layer_norm.bias""")						)

      # transformer decoder
      for i in range(config.decoder_layers						):
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.weight""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.bias""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", f"""model.decoder.layers.{i}.self_attn.out_proj.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", f"""model.decoder.layers.{i}.self_attn.out_proj.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.weight""", f"""model.decoder.layers.{i}.self_attn_layer_norm.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.bias""", f"""model.decoder.layers.{i}.self_attn_layer_norm.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.weight""", f"""model.decoder.layers.{i}.fc1.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.bias""", f"""model.decoder.layers.{i}.fc1.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.weight""", f"""model.decoder.layers.{i}.fc2.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.bias""", f"""model.decoder.layers.{i}.fc2.bias""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.weight""", f"""model.decoder.layers.{i}.final_layer_norm.weight""")						)
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.bias""", f"""model.decoder.layers.{i}.final_layer_norm.bias""")						)

      # fmt: on

      return rename_keys







def 		_lowercase (     lowercase__   ,	lowercase__   ,	lowercase__						):
      __lowerCAmelCase					:						Any					=					dct.pop(SCREAMING_SNAKE_CASE__						)
      __lowerCAmelCase					:						Optional[int]					=					val







def 		_lowercase (     lowercase__   ,	lowercase__						):
      __lowerCAmelCase					:						Any					=					[int(backbone_config.embed_dim * 2**i						) for i in range(len(backbone_config.depths						)						)]
      for i in range(len(backbone_config.depths						)						):
            __lowerCAmelCase					:						Optional[Any]					=					num_features[i]
            for j in range(backbone_config.depths[i]						):
                  # fmt: off
                  # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
                  __lowerCAmelCase					:						Optional[int]					=					state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"""						)
                  __lowerCAmelCase					:						int					=					state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"""						)
                  # next, add query, keys and values (in that order) to the state dict
                  __lowerCAmelCase					:						str					=					in_proj_weight[:dim, :]
                  __lowerCAmelCase					:						int					=					in_proj_bias[: dim]
                  __lowerCAmelCase					:						int					=					in_proj_weight[
                      dim : dim * 2, :
                  ]
                  __lowerCAmelCase					:						List[str]					=					in_proj_bias[
                      dim : dim * 2
                  ]
                  __lowerCAmelCase					:						int					=					in_proj_weight[
                      -dim :, :
                  ]
                  __lowerCAmelCase					:						List[str]					=					in_proj_bias[-dim :]
                  # fmt: on







def 		_lowercase (     lowercase__   ,	lowercase__						):
      __lowerCAmelCase					:						int					=					config.d_model
      for i in range(config.decoder_layers						):
            # read in weights + bias of input projection layer of self-attention
            __lowerCAmelCase					:						Optional[int]					=					state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""						)
            __lowerCAmelCase					:						Tuple					=					state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_bias"""						)
            # next, add query, keys and values (in that order) to the state dict
            __lowerCAmelCase					:						Tuple					=					in_proj_weight[:hidden_size, :]
            __lowerCAmelCase					:						Union[str, Any]					=					in_proj_bias[:hidden_size]
            __lowerCAmelCase					:						Tuple					=					in_proj_weight[
                hidden_size : hidden_size * 2, :
            ]
            __lowerCAmelCase					:						List[Any]					=					in_proj_bias[hidden_size : hidden_size * 2]
            __lowerCAmelCase					:						Optional[Any]					=					in_proj_weight[-hidden_size:, :]
            __lowerCAmelCase					:						Any					=					in_proj_bias[-hidden_size:]







def 		_lowercase (     ):
      __lowerCAmelCase					:						int					=					"""http://images.cocodataset.org/val2017/000000039769.jpg"""
      __lowerCAmelCase					:						int					=					Image.open(requests.get(SCREAMING_SNAKE_CASE__   ,	stream=SCREAMING_SNAKE_CASE__						).raw						)

      return im







@torch.no_grad()
def 		_lowercase (     lowercase__   ,	lowercase__   ,	lowercase__						):
      __lowerCAmelCase					:						Union[str, Any]					=					get_deta_config(SCREAMING_SNAKE_CASE__						)

      # load original state dict
      if model_name == "deta-swin-large":
            __lowerCAmelCase					:						Dict					=					hf_hub_download(repo_id='''nielsr/deta-checkpoints'''   ,	filename='''adet_swin_ft.pth'''						)
      elif model_name == "deta-swin-large-o365":
            __lowerCAmelCase					:						str					=					hf_hub_download(repo_id='''jozhang97/deta-swin-l-o365'''   ,	filename='''deta_swin_pt_o365.pth'''						)
      else:
            raise ValueError(f"""Model name {model_name} not supported"""						)

      __lowerCAmelCase					:						Optional[int]					=					torch.load(SCREAMING_SNAKE_CASE__   ,	map_location='''cpu'''						)["""model"""]

      # original state dict
      for name, param in state_dict.items():
            print(SCREAMING_SNAKE_CASE__   ,	param.shape						)

      # rename keys
      __lowerCAmelCase					:						int					=					create_rename_keys(SCREAMING_SNAKE_CASE__						)
      for src, dest in rename_keys:
            rename_key(SCREAMING_SNAKE_CASE__   ,	SCREAMING_SNAKE_CASE__   ,	SCREAMING_SNAKE_CASE__						)
      read_in_swin_q_k_v(SCREAMING_SNAKE_CASE__   ,	config.backbone_config						)
      read_in_decoder_q_k_v(SCREAMING_SNAKE_CASE__   ,	SCREAMING_SNAKE_CASE__						)

      # fix some prefixes
      for key in state_dict.copy().keys():
            if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
                  __lowerCAmelCase					:						int					=					state_dict.pop(SCREAMING_SNAKE_CASE__						)
                  __lowerCAmelCase					:						List[str]					=					val
            if "input_proj" in key:
                  __lowerCAmelCase					:						Union[str, Any]					=					state_dict.pop(SCREAMING_SNAKE_CASE__						)
                  __lowerCAmelCase					:						List[str]					=					val
            if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
                  __lowerCAmelCase					:						List[str]					=					state_dict.pop(SCREAMING_SNAKE_CASE__						)
                  __lowerCAmelCase					:						Optional[Any]					=					val

    # finally, create HuggingFace model and load state dict
      __lowerCAmelCase					:						Tuple					=					DetaForObjectDetection(SCREAMING_SNAKE_CASE__						)
      model.load_state_dict(SCREAMING_SNAKE_CASE__						)
      model.eval()

      __lowerCAmelCase					:						Dict					=					"""cuda""" if torch.cuda.is_available() else """cpu"""
      model.to(SCREAMING_SNAKE_CASE__						)

      # load image processor
      __lowerCAmelCase					:						Any					=					DetaImageProcessor(format='''coco_detection'''						)

      # verify our conversion on image
      __lowerCAmelCase					:						str					=					prepare_img()
      __lowerCAmelCase					:						Dict					=					processor(images=SCREAMING_SNAKE_CASE__   ,	return_tensors='''pt'''						)
      __lowerCAmelCase					:						List[str]					=					encoding["""pixel_values"""]
      __lowerCAmelCase					:						Optional[int]					=					model(pixel_values.to(SCREAMING_SNAKE_CASE__						)						)

      # verify logits
      print('''Logits:'''   ,	outputs.logits[0, :3, :3]						)
      print('''Boxes:'''   ,	outputs.pred_boxes[0, :3, :3]						)
      if model_name == "deta-swin-large":
            __lowerCAmelCase					:						Union[str, Any]					=					torch.tensor(
                [[-7.6_3_0_8, -2.8_4_8_5, -5.3_7_3_7], [-7.2_0_3_7, -4.5_5_0_5, -4.8_0_2_7], [-7.2_9_4_3, -4.2_6_1_1, -4.6_6_1_7]]						)
            __lowerCAmelCase					:						List[Any]					=					torch.tensor([[0.4_9_8_7, 0.4_9_6_9, 0.9_9_9_9], [0.2_5_4_9, 0.5_4_9_8, 0.4_8_0_5], [0.5_4_9_8, 0.2_7_5_7, 0.0_5_6_9]]						)
      elif model_name == "deta-swin-large-o365":
            __lowerCAmelCase					:						List[str]					=					torch.tensor(
                [[-8.0_1_2_2, -3.5_7_2_0, -4.9_7_1_7], [-8.1_5_4_7, -3.6_8_8_6, -4.6_3_8_9], [-7.6_6_1_0, -3.6_1_9_4, -5.0_1_3_4]]						)
            __lowerCAmelCase					:						Optional[Any]					=					torch.tensor([[0.2_5_2_3, 0.5_5_4_9, 0.4_8_8_1], [0.7_7_1_5, 0.4_1_4_9, 0.4_6_0_1], [0.5_5_0_3, 0.2_7_5_3, 0.0_5_7_5]]						)
      assert torch.allclose(outputs.logits[0, :3, :3]   ,	expected_logits.to(SCREAMING_SNAKE_CASE__						)   ,	atol=1E-4						)
      assert torch.allclose(outputs.pred_boxes[0, :3, :3]   ,	expected_boxes.to(SCREAMING_SNAKE_CASE__						)   ,	atol=1E-4						)
      print('''Everything ok!'''						)

      if pytorch_dump_folder_path:
            # Save model and processor
            logger.info(f"""Saving PyTorch model and processor to {pytorch_dump_folder_path}..."""						)
            Path(SCREAMING_SNAKE_CASE__						).mkdir(exist_ok=SCREAMING_SNAKE_CASE__						)
            model.save_pretrained(SCREAMING_SNAKE_CASE__						)
            processor.save_pretrained(SCREAMING_SNAKE_CASE__						)

      # Push to hub
      if push_to_hub:
            print('''Pushing model and processor to hub...'''						)
            model.push_to_hub(f"""jozhang97/{model_name}"""						)
            processor.push_to_hub(f"""jozhang97/{model_name}"""						)


if __name__ == "__main__":
 _UpperCamelCase 			=		argparse.ArgumentParser()

 parser.add_argument(
     "--model_name",
     type=str,
     default="deta-swin-large",
     choices=["deta-swin-large", "deta-swin-large-o365"],
     help="Name of the model you\'d like to convert.",
 )
 parser.add_argument(
     "--pytorch_dump_folder_path",
     default=None,
     type=str,
     help="Path to the folder to output PyTorch model.",
 )
 parser.add_argument(
     "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
 )
 _UpperCamelCase 			=		parser.parse_args()
 convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






'''simple docstring'''


import unittest

from knapsack import greedy_knapsack as kp





class     lowercase__  (						unittest.TestCase					):





							'''simple docstring'''


							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       str     		=      [10, 20, 30, 40, 50, 60]
											_SCREAMING_SNAKE_CASE :       List[str]     		=      [2, 4, 6, 8, 10, 12]
											_SCREAMING_SNAKE_CASE :       str     		=      100
											self.assertEqual(kp.calc_profit(__snake_case    ,					__snake_case    ,					__snake_case  )    ,					210  )






							def UpperCAmelCase_	(    self  ):
											self.assertRaisesRegex(__snake_case    ,					"""max_weight must greater than zero."""  )






							def UpperCAmelCase_	(    self  ):
											self.assertRaisesRegex(__snake_case    ,					"""Weight can not be negative."""  )






							def UpperCAmelCase_	(    self  ):
											self.assertRaisesRegex(__snake_case    ,					"""Profit can not be negative."""  )






							def UpperCAmelCase_	(    self  ):
											self.assertRaisesRegex(__snake_case    ,					"""max_weight must greater than zero."""  )






							def UpperCAmelCase_	(    self  ):
											self.assertRaisesRegex(
											    __snake_case    ,					"""The length of profit and weight must be same."""  )


if __name__ == "__main__":
				unittest.main()




