

# This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/

import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()






class 	UpperCAmelCase__		(	A__						,					A__						,					A__						,					unittest.TestCase	):






  """simple docstring"""


  a									= StableDiffusionControlNetImgaImgPipeline
  a									= TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
  a									= TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  a									= IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"control_image"}	)
  a									= IMAGE_TO_IMAGE_IMAGE_PARAMS






  def 				lowercase_		(							self						:		List[Any] )		->							Union[str, Any]:
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   UNetaDConditionModel(
           block_out_channels=(32, 64)     ,       layers_per_block=2     ,       sample_size=32     ,       in_channels=4     ,       out_channels=4     ,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,       up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,       cross_attention_dim=32     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   ControlNetModel(
           block_out_channels=(32, 64)     ,       layers_per_block=2     ,       in_channels=4     ,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,       cross_attention_dim=32     ,       conditioning_embedding_out_channels=(16, 32)     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   DDIMScheduler(
           beta_start=0.00085     ,       beta_end=0.012     ,       beta_schedule='''scaled_linear'''     ,       clip_sample=__lowerCamelCase     ,       set_alpha_to_one=__lowerCamelCase     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   AutoencoderKL(
           block_out_channels=[32, 64]     ,       in_channels=3     ,       out_channels=3     ,       down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,       up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,       latent_channels=4     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   CLIPTextConfig(
           bos_token_id=0     ,       eos_token_id=2     ,       hidden_size=32     ,       intermediate_size=37     ,       layer_norm_eps=1e-05     ,       num_attention_heads=4     ,       num_hidden_layers=5     ,       pad_token_id=1     ,       vocab_size=1000     ,       )
       SCREAMING_SNAKE_CASE__   =   CLIPTextModel(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )

       SCREAMING_SNAKE_CASE__   =   {
           '''unet''': unet,
           '''controlnet''': controlnet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       return components






  def 				lowercase_		(							self						:		str     ,       __lowerCamelCase						:		List[str]     ,       __lowerCamelCase						:		List[Any]=0 )		->							Union[str, Any]:
       if str(__lowerCamelCase ).startswith('''mps''' ):
            SCREAMING_SNAKE_CASE__   =   torch.manual_seed(__lowerCamelCase )
       else:
            SCREAMING_SNAKE_CASE__   =   torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   2
       SCREAMING_SNAKE_CASE__   =   randn_tensor(
           (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     ,       generator=__lowerCamelCase     ,       device=torch.device(__lowerCamelCase )     ,       )
       SCREAMING_SNAKE_CASE__   =   floats_tensor(control_image.shape     ,       rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   image.cpu().permute(0     ,       2     ,       3     ,       1 )[0]
       SCREAMING_SNAKE_CASE__   =   Image.fromarray(np.uinta(__lowerCamelCase ) ).convert('''RGB''' ).resize((64, 64) )
       SCREAMING_SNAKE_CASE__   =   {
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 6.0,
           '''output_type''': '''numpy''',
           '''image''': image,
           '''control_image''': control_image,
       }

       return inputs






  def 				lowercase_		(							self						:		List[str] )		->							Any:
       return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3 )






  @unittest.skipIf(
      torch_device != '''cuda''' or not is_xformers_available()     ,       reason='''XFormers attention is only available with CUDA and `xformers` installed'''     ,       )
  def 				lowercase_		(							self						:		Union[str, Any] )		->							List[str]:
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3 )







  def 				lowercase_		(							self						:		Any )		->							int:
       self._test_inference_batch_single_identical(expected_max_diff=2e-3 )






class 	UpperCAmelCase__		(	A__						,					A__						,					unittest.TestCase	):






  """simple docstring"""


  a									= StableDiffusionControlNetImgaImgPipeline
  a									= TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
  a									= TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  a									= frozenset([]	)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess






  def 				lowercase_		(							self						:		Optional[Any] )		->							Dict:
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   UNetaDConditionModel(
           block_out_channels=(32, 64)     ,       layers_per_block=2     ,       sample_size=32     ,       in_channels=4     ,       out_channels=4     ,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,       up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,       cross_attention_dim=32     ,       )
       torch.manual_seed(0 )

       def init_weights(__lowerCamelCase						:		List[str] ):
            if isinstance(__lowerCamelCase     ,       torch.nn.Convad ):
                 torch.nn.init.normal(m.weight )
                 m.bias.data.fill_(1.0 )

       SCREAMING_SNAKE_CASE__   =   ControlNetModel(
           block_out_channels=(32, 64)     ,       layers_per_block=2     ,       in_channels=4     ,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,       cross_attention_dim=32     ,       conditioning_embedding_out_channels=(16, 32)     ,       )
       controlneta.controlnet_down_blocks.apply(__lowerCamelCase )

       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   ControlNetModel(
           block_out_channels=(32, 64)     ,       layers_per_block=2     ,       in_channels=4     ,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,       cross_attention_dim=32     ,       conditioning_embedding_out_channels=(16, 32)     ,       )
       controlneta.controlnet_down_blocks.apply(__lowerCamelCase )

       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   DDIMScheduler(
           beta_start=0.00085     ,       beta_end=0.012     ,       beta_schedule='''scaled_linear'''     ,       clip_sample=__lowerCamelCase     ,       set_alpha_to_one=__lowerCamelCase     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   AutoencoderKL(
           block_out_channels=[32, 64]     ,       in_channels=3     ,       out_channels=3     ,       down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,       up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,       latent_channels=4     ,       )
       torch.manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   CLIPTextConfig(
           bos_token_id=0     ,       eos_token_id=2     ,       hidden_size=32     ,       intermediate_size=37     ,       layer_norm_eps=1e-05     ,       num_attention_heads=4     ,       num_hidden_layers=5     ,       pad_token_id=1     ,       vocab_size=1000     ,       )
       SCREAMING_SNAKE_CASE__   =   CLIPTextModel(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )

       SCREAMING_SNAKE_CASE__   =   MultiControlNetModel([controlneta, controlneta] )

       SCREAMING_SNAKE_CASE__   =   {
           '''unet''': unet,
           '''controlnet''': controlnet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       return components






  def 				lowercase_		(							self						:		Dict     ,       __lowerCamelCase						:		int     ,       __lowerCamelCase						:		str=0 )		->							Tuple:
       if str(__lowerCamelCase ).startswith('''mps''' ):
            SCREAMING_SNAKE_CASE__   =   torch.manual_seed(__lowerCamelCase )
       else:
            SCREAMING_SNAKE_CASE__   =   torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   2

       SCREAMING_SNAKE_CASE__   =   [
           randn_tensor(
               (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     ,       generator=__lowerCamelCase     ,       device=torch.device(__lowerCamelCase )     ,       ),
           randn_tensor(
               (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)     ,       generator=__lowerCamelCase     ,       device=torch.device(__lowerCamelCase )     ,       ),
       ]

       SCREAMING_SNAKE_CASE__   =   floats_tensor(control_image[0].shape     ,       rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   image.cpu().permute(0     ,       2     ,       3     ,       1 )[0]
       SCREAMING_SNAKE_CASE__   =   Image.fromarray(np.uinta(__lowerCamelCase ) ).convert('''RGB''' ).resize((64, 64) )
       SCREAMING_SNAKE_CASE__   =   {
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 6.0,
           '''output_type''': '''numpy''',
           '''image''': image,
           '''control_image''': control_image,
       }

       return inputs






  def 				lowercase_		(							self						:		str )		->							int:
       SCREAMING_SNAKE_CASE__   =   self.get_dummy_components()
       SCREAMING_SNAKE_CASE__   =   self.pipeline_class(**__lowerCamelCase )
       pipe.to(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   10.0
       SCREAMING_SNAKE_CASE__   =   4

       SCREAMING_SNAKE_CASE__   =   self.get_dummy_inputs(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   steps
       SCREAMING_SNAKE_CASE__   =   scale
       SCREAMING_SNAKE_CASE__   =   pipe(**__lowerCamelCase )[0]

       SCREAMING_SNAKE_CASE__   =   self.get_dummy_inputs(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   steps
       SCREAMING_SNAKE_CASE__   =   scale
       SCREAMING_SNAKE_CASE__   =   pipe(**__lowerCamelCase     ,       control_guidance_start=0.1     ,       control_guidance_end=0.2 )[0]

       SCREAMING_SNAKE_CASE__   =   self.get_dummy_inputs(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   steps
       SCREAMING_SNAKE_CASE__   =   scale
       SCREAMING_SNAKE_CASE__   =   pipe(**__lowerCamelCase     ,       control_guidance_start=[0.1, 0.3]     ,       control_guidance_end=[0.2, 0.7] )[0]

       SCREAMING_SNAKE_CASE__   =   self.get_dummy_inputs(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   steps
       SCREAMING_SNAKE_CASE__   =   scale
       SCREAMING_SNAKE_CASE__   =   pipe(**__lowerCamelCase     ,       control_guidance_start=0.4     ,       control_guidance_end=[0.5, 0.8] )[0]

       # make sure that all outputs are different
       assert np.sum(np.abs(output_a - output_a ) ) > 1e-3
       assert np.sum(np.abs(output_a - output_a ) ) > 1e-3
       assert np.sum(np.abs(output_a - output_a ) ) > 1e-3






  def 				lowercase_		(							self						:		List[str] )		->							Tuple:
       return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3 )






  @unittest.skipIf(
      torch_device != '''cuda''' or not is_xformers_available()     ,       reason='''XFormers attention is only available with CUDA and `xformers` installed'''     ,       )
  def 				lowercase_		(							self						:		int )		->							Any:
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3 )






  def 				lowercase_		(							self						:		int )		->							int:
       self._test_inference_batch_single_identical(expected_max_diff=2e-3 )







  def 				lowercase_		(							self						:		List[Any] )		->							Any:
       SCREAMING_SNAKE_CASE__   =   self.get_dummy_components()
       SCREAMING_SNAKE_CASE__   =   self.pipeline_class(**__lowerCamelCase )
       pipe.to(__lowerCamelCase )
       pipe.set_progress_bar_config(disable=__lowerCamelCase )
       with tempfile.TemporaryDirectory() as tmpdir:
            try:
                 # save_pretrained is not implemented for Multi-ControlNet
                 pipe.save_pretrained(__lowerCamelCase )
            except NotImplementedError:
                 pass






@slow
@require_torch_gpu
class 	UpperCAmelCase__		(	unittest.TestCase	):






  """simple docstring"""


  def 				lowercase_		(							self						:		List[Any] )		->							Any:
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







  def 				lowercase_		(							self						:		int )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny''' )

       SCREAMING_SNAKE_CASE__   =   StableDiffusionControlNetImgaImgPipeline.from_pretrained(
           '''runwayml/stable-diffusion-v1-5'''     ,       safety_checker=__lowerCamelCase     ,       controlnet=__lowerCamelCase )
       pipe.enable_model_cpu_offload()
       pipe.set_progress_bar_config(disable=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   torch.Generator(device='''cpu''' ).manual_seed(0 )
       SCREAMING_SNAKE_CASE__   =   '''evil space-punk bird'''
       SCREAMING_SNAKE_CASE__   =   load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png''' ).resize((512, 512) )
       SCREAMING_SNAKE_CASE__   =   load_image(
           '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png''' ).resize((512, 512) )

       SCREAMING_SNAKE_CASE__   =   pipe(
           __lowerCamelCase     ,       __lowerCamelCase     ,       control_image=__lowerCamelCase     ,       generator=__lowerCamelCase     ,       output_type='''np'''     ,       num_inference_steps=50     ,       strength=0.6     ,       )

       SCREAMING_SNAKE_CASE__   =   output.images[0]

       assert image.shape == (512, 512, 3)

       SCREAMING_SNAKE_CASE__   =   load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy''' )

       assert np.abs(expected_image - image ).max() < 9e-2





import argparse
import copy
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   {}

     with open(_A    ) as f:
          for line in f:
               if line.split()[0] not in dict_of_neighbours:
                    SCREAMING_SNAKE_CASE__   =   []
                    _list.append([line.split()[1], line.split()[2]]    )
                    SCREAMING_SNAKE_CASE__   =   _list
               else:
                    dict_of_neighbours[line.split()[0]].append(
                        [line.split()[1], line.split()[2]]    )
               if line.split()[1] not in dict_of_neighbours:
                    SCREAMING_SNAKE_CASE__   =   []
                    _list.append([line.split()[0], line.split()[2]]    )
                    SCREAMING_SNAKE_CASE__   =   _list
               else:
                    dict_of_neighbours[line.split()[1]].append(
                        [line.split()[0], line.split()[2]]    )

     return dict_of_neighbours
def     UpperCAmelCase_       (						_A				,		_A    ):





     '''simple docstring'''




     with open(_A    ) as f:
          SCREAMING_SNAKE_CASE__   =   f.read(1    )
     SCREAMING_SNAKE_CASE__   =   start_node

     SCREAMING_SNAKE_CASE__   =   []

     SCREAMING_SNAKE_CASE__   =   start_node

     SCREAMING_SNAKE_CASE__   =   0
     while visiting not in first_solution:
          SCREAMING_SNAKE_CASE__   =   1_00_00
          for k in dict_of_neighbours[visiting]:
               if int(k[1]    ) < int(_A    ) and k[0] not in first_solution:
                    SCREAMING_SNAKE_CASE__   =   k[1]
                    SCREAMING_SNAKE_CASE__   =   k[0]

          first_solution.append(_A    )
          SCREAMING_SNAKE_CASE__   =   distance_of_first_solution + int(_A    )
          SCREAMING_SNAKE_CASE__   =   best_node

     first_solution.append(_A    )

     SCREAMING_SNAKE_CASE__   =   0
     for k in dict_of_neighbours[first_solution[-2]]:
          if k[0] == start_node:
               break
          position += 1

     SCREAMING_SNAKE_CASE__   =   (
         distance_of_first_solution
         + int(dict_of_neighbours[first_solution[-2]][position][1]    )
         - 1_00_00
     )
     return first_solution, distance_of_first_solution
def     UpperCAmelCase_       (						_A				,		_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   []

     for n in solution[1:-1]:
          SCREAMING_SNAKE_CASE__   =   solution.index(_A    )
          for kn in solution[1:-1]:
               SCREAMING_SNAKE_CASE__   =   solution.index(_A    )
               if n == kn:
                    continue

               SCREAMING_SNAKE_CASE__   =   copy.deepcopy(_A    )
               SCREAMING_SNAKE_CASE__   =   kn
               SCREAMING_SNAKE_CASE__   =   n

               SCREAMING_SNAKE_CASE__   =   0

               for k in _tmp[:-1]:
                    SCREAMING_SNAKE_CASE__   =   _tmp[_tmp.index(_A    ) + 1]
                    for i in dict_of_neighbours[k]:
                         if i[0] == next_node:
                              SCREAMING_SNAKE_CASE__   =   distance + int(i[1]    )
               _tmp.append(_A    )

               if _tmp not in neighborhood_of_solution:
                    neighborhood_of_solution.append(_tmp    )

     SCREAMING_SNAKE_CASE__   =   len(neighborhood_of_solution[0]    ) - 1

     neighborhood_of_solution.sort(key=lambda _A    : x[index_of_last_item_in_the_list]    )
     return neighborhood_of_solution
def     UpperCAmelCase_       (						_A				,		_A				,		_A				,		_A				,		_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   1
     SCREAMING_SNAKE_CASE__   =   first_solution
     SCREAMING_SNAKE_CASE__   =   []
     SCREAMING_SNAKE_CASE__   =   distance_of_first_solution
     SCREAMING_SNAKE_CASE__   =   solution

     while count <= iters:
          SCREAMING_SNAKE_CASE__   =   find_neighborhood(_A				,		_A    )
          SCREAMING_SNAKE_CASE__   =   0
          SCREAMING_SNAKE_CASE__   =   neighborhood[index_of_best_solution]
          SCREAMING_SNAKE_CASE__   =   len(_A    ) - 1

          SCREAMING_SNAKE_CASE__   =   False
          while not found:
               SCREAMING_SNAKE_CASE__   =   0
               while i < len(_A    ):
                    if best_solution[i] != solution[i]:
                         SCREAMING_SNAKE_CASE__   =   best_solution[i]
                         SCREAMING_SNAKE_CASE__   =   solution[i]
                         break
                    SCREAMING_SNAKE_CASE__   =   i + 1

               if [first_exchange_node, second_exchange_node] not in tabu_list and [
                   second_exchange_node,
                   first_exchange_node,
               ] not in tabu_list:
                    tabu_list.append([first_exchange_node, second_exchange_node]    )
                    SCREAMING_SNAKE_CASE__   =   True
                    SCREAMING_SNAKE_CASE__   =   best_solution[:-1]
                    SCREAMING_SNAKE_CASE__   =   neighborhood[index_of_best_solution][best_cost_index]
                    if cost < best_cost:
                         SCREAMING_SNAKE_CASE__   =   cost
                         SCREAMING_SNAKE_CASE__   =   solution
               else:
                    SCREAMING_SNAKE_CASE__   =   index_of_best_solution + 1
                    SCREAMING_SNAKE_CASE__   =   neighborhood[index_of_best_solution]

          if len(_A    ) >= size:
               tabu_list.pop(0    )

          SCREAMING_SNAKE_CASE__   =   count + 1

     return best_solution_ever, best_cost
def     UpperCAmelCase_       (						_A=None    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   generate_neighbours(args.File    )

     SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   generate_first_solution(
         args.File				,		_A    )

     SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   tabu_search(
         _A				,		_A				,		_A				,		args.Iterations				,		args.Size				,		)

     print(F'''Best solution: {best_sol}, with total distance: {best_cost}.'''    )


if __name__ == "__main__":
       _SCREAMING_SNAKE_CASE					:  Tuple             =      argparse.ArgumentParser(description='''Tabu Search''')
       parser.add_argument(
           '''-f''',
           '''--File''',
           type=str,
           help='''Path to the file containing the data''',
           required=True,
       )
       parser.add_argument(
           '''-i''',
           '''--Iterations''',
           type=int,
           help='''How many iterations the algorithm should perform''',
           required=True,
       )
       parser.add_argument(
           '''-s''', '''--Size''', type=int, help='''Size of the tabu list''', required=True
       )

       # Pass the arguments to main method
       main(parser.parse_args())


