

'''simple docstring'''







class 					A__      :



    def __init__(					self       )						->      Union[str, Any]:





           '''simple docstring'''
           A_						=      """"""
           A_						=      """"""
           A_						=      []



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      int:





           '''simple docstring'''
           if m == -1:
                  return n + 1
           elif n == -1:
                  return m + 1
           elif self.dp[m][n] > -1:
                  return self.dp[m][n]
           else:
                  if self.worda[m] == self.worda[n]:
                         A_						=      self.__min_dist_top_down_dp(m - 1		,				n - 1       )
                  else:
                         A_						=      self.__min_dist_top_down_dp(UpperCamelCase__		,				n - 1       )
                         A_						=      self.__min_dist_top_down_dp(m - 1		,				UpperCamelCase__       )
                         A_						=      self.__min_dist_top_down_dp(m - 1		,				n - 1       )
                         A_						=      1 + min(UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )

                  return self.dp[m][n]



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      int:





           '''simple docstring'''
           A_						=      worda
           A_						=      worda
           A_						=      [[-1 for _ in range(len(UpperCamelCase__       )       )] for _ in range(len(UpperCamelCase__       )       )]

           return self.__min_dist_top_down_dp(len(UpperCamelCase__       ) - 1		,				len(UpperCamelCase__       ) - 1       )







    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      int:





           '''simple docstring'''
           A_						=      worda
           A_						=      worda
           A_						=      len(UpperCamelCase__       )
           A_						=      len(UpperCamelCase__       )
           A_						=      [[0 for _ in range(n + 1       )] for _ in range(m + 1       )]

           for i in range(m + 1       ):
                  for j in range(n + 1       ):
                         if i == 0:  # first string is empty
                                A_						=      j
                         elif j == 0:  # second string is empty
                                A_						=      i
                         elif worda[i - 1] == worda[j - 1]:  # last characters are equal
                                A_						=      self.dp[i - 1][j - 1]
                         else:
                                A_						=      self.dp[i][j - 1]
                                A_						=      self.dp[i - 1][j]
                                A_						=      self.dp[i - 1][j - 1]
                                A_						=      1 + min(UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )
           return self.dp[m][n]


if __name__ == "__main__":
      __lowerCamelCase		       =    EditDistance()

      print('''****************** Testing Edit Distance DP Algorithm ******************''')
      print()

      __lowerCamelCase		       =    input('''Enter the first string: ''').strip()
      __lowerCamelCase		       =    input('''Enter the second string: ''').strip()

      print()
      print(f"""The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}""")
      print(f"""The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}""")
      print()
      print('''*************** End of Testing Edit Distance DP Algorithm ***************''')



'''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__    (      UpperCAmelCase__				)			->			Tuple:
       return EnvironmentCommand()
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			int:
       return EnvironmentCommand(args.accelerate_config_file				)







class 					A__      (      _snake_case			):



    @staticmethod
    def 					snake_case_			(					UpperCamelCase__       )						->      Union[str, Any]:





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



    def __init__(					self		,				UpperCamelCase__		,				*UpperCamelCase__       )						->      None:





           '''simple docstring'''
           A_						=      accelerate_config_file



    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           A_						=      """not installed"""
           if is_safetensors_available():
                  import safetensors

                  A_						=      safetensors.__version__
           elif importlib.util.find_spec("""safetensors"""       ) is not None:
                  import safetensors

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

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

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

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

           A_						=      """not installed"""
           A_						=      """NA"""
           if is_torch_available():
                  import torch

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

           A_						=      """not installed"""
           A_						=      """NA"""
           if is_tf_available():
                  import tensorflow as tf

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

           A_						=      """not installed"""
           A_						=      """not installed"""
           A_						=      """not installed"""
           A_						=      """NA"""
           if is_flax_available():
                  import flax
                  import jax
                  import jaxlib

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

           A_						=      {
               """`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(UpperCamelCase__       )       )

           return info







    @staticmethod
    def 					snake_case_			(					UpperCamelCase__       )						->      List[str]:





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