
'''simple docstring'''






import argparse
import copy







def 		A_							(						_lowerCAmelCase :     str				):



      """simple docstring"""




      _lowerCamelCase					: Optional[Any]		    = {}

      with open(_lowerCAmelCase				) as f:
            for line in f:
                  if line.split()[0] not in dict_of_neighbours:
                        _lowerCamelCase					: Dict		    = []
                        _list.append([line.split()[1], line.split()[2]]				)
                        _lowerCamelCase					: List[Any]		    = _list
                  else:
                        dict_of_neighbours[line.split()[0]].append(
                            [line.split()[1], line.split()[2]]				)
                  if line.split()[1] not in dict_of_neighbours:
                        _lowerCamelCase					: List[Any]		    = []
                        _list.append([line.split()[0], line.split()[2]]				)
                        _lowerCamelCase					: Dict		    = _list
                  else:
                        dict_of_neighbours[line.split()[1]].append(
                            [line.split()[0], line.split()[2]]				)

      return dict_of_neighbours







def 		A_							(						_lowerCAmelCase :     Dict					,						_lowerCAmelCase :     Dict				):



      """simple docstring"""




      with open(_lowerCAmelCase				) as f:
            _lowerCamelCase					: Optional[Any]		    = f.read(1				)
      _lowerCamelCase					: Optional[int]		    = start_node

      _lowerCamelCase					: List[Any]		    = []

      _lowerCamelCase					: List[str]		    = start_node

      _lowerCamelCase					: Optional[Any]		    = 0
      while visiting not in first_solution:
            _lowerCamelCase					: Any		    = 10000
            for k in dict_of_neighbours[visiting]:
                  if int(k[1]				) < int(_lowerCAmelCase				) and k[0] not in first_solution:
                        _lowerCamelCase					: Optional[int]		    = k[1]
                        _lowerCamelCase					: Tuple		    = k[0]

            first_solution.append(_lowerCAmelCase				)
            _lowerCamelCase					: Any		    = distance_of_first_solution + int(_lowerCAmelCase				)
            _lowerCamelCase					: Optional[int]		    = best_node

      first_solution.append(_lowerCAmelCase				)

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

      _lowerCamelCase					: Optional[Any]		    = (
          distance_of_first_solution
          + int(dict_of_neighbours[first_solution[-2]][position][1]				)
          - 10000
      )
      return first_solution, distance_of_first_solution







def 		A_							(						_lowerCAmelCase :     List[str]					,						_lowerCAmelCase :     Optional[Any]				):



      """simple docstring"""




      _lowerCamelCase					: Dict		    = []

      for n in solution[1:-1]:
            _lowerCamelCase					: int		    = solution.index(_lowerCAmelCase				)
            for kn in solution[1:-1]:
                  _lowerCamelCase					: List[str]		    = solution.index(_lowerCAmelCase				)
                  if n == kn:
                        continue

                  _lowerCamelCase					: Dict		    = copy.deepcopy(_lowerCAmelCase				)
                  _lowerCamelCase					: Union[str, Any]		    = kn
                  _lowerCamelCase					: List[Any]		    = n

                  _lowerCamelCase					: Any		    = 0

                  for k in _tmp[:-1]:
                        _lowerCamelCase					: Union[str, Any]		    = _tmp[_tmp.index(_lowerCAmelCase				) + 1]
                        for i in dict_of_neighbours[k]:
                              if i[0] == next_node:
                                    _lowerCamelCase					: int		    = distance + int(i[1]				)
                  _tmp.append(_lowerCAmelCase				)

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

      _lowerCamelCase					: List[Any]		    = len(neighborhood_of_solution[0]				) - 1

      neighborhood_of_solution.sort(key=lambda _lowerCAmelCase				: x[index_of_last_item_in_the_list]				)
      return neighborhood_of_solution







def 		A_							(						_lowerCAmelCase :     List[Any]					,						_lowerCAmelCase :     Dict					,						_lowerCAmelCase :     int					,						_lowerCAmelCase :     Tuple					,						_lowerCAmelCase :     List[Any]				):



      """simple docstring"""




      _lowerCamelCase					: Dict		    = 1
      _lowerCamelCase					: Union[str, Any]		    = first_solution
      _lowerCamelCase					: Optional[Any]		    = []
      _lowerCamelCase					: Optional[int]		    = distance_of_first_solution
      _lowerCamelCase					: List[str]		    = solution

      while count <= iters:
            _lowerCamelCase					: List[str]		    = find_neighborhood(_lowerCAmelCase					,						_lowerCAmelCase				)
            _lowerCamelCase					: List[Any]		    = 0
            _lowerCamelCase					: List[Any]		    = neighborhood[index_of_best_solution]
            _lowerCamelCase					: Optional[Any]		    = len(_lowerCAmelCase				) - 1

            _lowerCamelCase					: List[str]		    = False
            while not found:
                  _lowerCamelCase					: str		    = 0
                  while i < len(_lowerCAmelCase				):
                        if best_solution[i] != solution[i]:
                              _lowerCamelCase					: str		    = best_solution[i]
                              _lowerCamelCase					: Any		    = solution[i]
                              break
                        _lowerCamelCase					: List[Any]		    = 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]				)
                        _lowerCamelCase					: Optional[int]		    = True
                        _lowerCamelCase					: Union[str, Any]		    = best_solution[:-1]
                        _lowerCamelCase					: Union[str, Any]		    = neighborhood[index_of_best_solution][best_cost_index]
                        if cost < best_cost:
                              _lowerCamelCase					: Tuple		    = cost
                              _lowerCamelCase					: List[str]		    = solution
                  else:
                        _lowerCamelCase					: Dict		    = index_of_best_solution + 1
                        _lowerCamelCase					: Any		    = neighborhood[index_of_best_solution]

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

            _lowerCamelCase					: Union[str, Any]		    = count + 1

      return best_solution_ever, best_cost







def 		A_							(						_lowerCAmelCase :     List[str]=None				):



      """simple docstring"""




      _lowerCamelCase					: Tuple		    = generate_neighbours(args.File				)

      _lowerCamelCase    ,		_lowerCamelCase					: Tuple		    = generate_first_solution(
          args.File					,						_lowerCAmelCase				)

      _lowerCamelCase    ,		_lowerCamelCase					: int		    = tabu_search(
          _lowerCAmelCase					,						_lowerCAmelCase					,						_lowerCAmelCase					,						args.Iterations					,						args.Size					,						)

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


if __name__ == "__main__":
 UpperCAmelCase_							: str =							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())


'''simple docstring'''

import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand

def 					__UpperCamelCase				(						lowercase__    :	Union[str, Any]			):






     '''simple docstring'''





     return EnvironmentCommand()

def 					__UpperCamelCase				(						lowercase__    :	Any			):






     '''simple docstring'''





     return EnvironmentCommand(args.accelerate_config_file			)







class 	lowerCAmelCase  (   A ):







       @staticmethod
       def       snake_case (				__lowercase      :			ArgumentParser   ):







            """simple docstring"""







            __lowercase      		=parser.add_parser('env'   )
            download_parser.set_defaults(func=__lowercase   )
            download_parser.add_argument(
                '--accelerate-config_file'    ,   default=__lowercase    ,   help='The accelerate config file to use for the default values in the launching script.'    ,   )
            download_parser.set_defaults(func=__lowercase   )







       def __init__(				self      :			int    ,   __lowercase      :			Any    ,   *__lowercase      :			str   ):







            """simple docstring"""







            __lowercase      		=accelerate_config_file







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







            __lowercase      		='not installed'
            if is_safetensors_available():
                 import safetensors

                 __lowercase      		=safetensors.__version__
            elif importlib.util.find_spec('safetensors'   ) is not None:
                 import safetensors

                 __lowercase      		=f'''{safetensors.__version__} but is ignored because of PyTorch version too old.'''

            __lowercase      		='not installed'
            __lowercase      		=__lowercase      		='not found'
            if is_accelerate_available():
                 import accelerate
                 from accelerate.commands.config import default_config_file, load_config_from_file

                 __lowercase      		=accelerate.__version__
                 # Get the default from the config file.
                 if self._accelerate_config_file is not None or os.path.isfile(__lowercase   ):
                      __lowercase      		=load_config_from_file(self._accelerate_config_file   ).to_dict()

                 __lowercase      		=(
                     '\n'.join([f'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()]   )
                     if isinstance(__lowercase    ,   __lowercase   )
                     else f'''\t{accelerate_config}'''
                 )

            __lowercase      		='not installed'
            __lowercase      		='NA'
            if is_torch_available():
                 import torch

                 __lowercase      		=torch.__version__
                 __lowercase      		=torch.cuda.is_available()

            __lowercase      		='not installed'
            __lowercase      		='NA'
            if is_tf_available():
                 import tensorflow as tf

                 __lowercase      		=tf.__version__
                 try:
                      # deprecated in v2.1
                      __lowercase      		=tf.test.is_gpu_available()
                 except AttributeError:
                      # returns list of devices, convert to bool
                      __lowercase      		=bool(tf.config.list_physical_devices('GPU'   )   )

            __lowercase      		='not installed'
            __lowercase      		='not installed'
            __lowercase      		='not installed'
            __lowercase      		='NA'
            if is_flax_available():
                 import flax
                 import jax
                 import jaxlib

                 __lowercase      		=flax.__version__
                 __lowercase      		=jax.__version__
                 __lowercase      		=jaxlib.__version__
                 __lowercase      		=jax.lib.xla_bridge.get_backend().platform

            __lowercase      		={
                '`transformers` version': version,
                'Platform': platform.platform(),
                'Python version': platform.python_version(),
                'Huggingface_hub version': huggingface_hub.__version__,
                'Safetensors version': f'''{safetensors_version}''',
                'Accelerate version': f'''{accelerate_version}''',
                'Accelerate config': f'''{accelerate_config_str}''',
                'PyTorch version (GPU?)': f'''{pt_version} ({pt_cuda_available})''',
                'Tensorflow version (GPU?)': f'''{tf_version} ({tf_cuda_available})''',
                'Flax version (CPU?/GPU?/TPU?)': f'''{flax_version} ({jax_backend})''',
                'Jax version': f'''{jax_version}''',
                'JaxLib version': f'''{jaxlib_version}''',
                'Using GPU in script?': '<fill in>',
                'Using distributed or parallel set-up in script?': '<fill in>',
            }

            print('\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n'   )
            print(self.format_dict(__lowercase   )   )

            return info







       @staticmethod
       def       snake_case (				__lowercase      :			Optional[Any]   ):







            """simple docstring"""







            return "\n".join([f'''- {prop}: {val}''' for prop, val in d.items()]   ) + "\n"


