


"""simple docstring"""






import os
import pickle
import unittest
from collections import UserDict, namedtuple

import torch

from accelerate.test_utils.testing import require_cuda, require_torch_min_version
from accelerate.test_utils.training import RegressionModel
from accelerate.utils import (
    convert_outputs_to_fpaa,
    extract_model_from_parallel,
    find_device,
    listify,
    patch_environment,
    recursively_apply,
    send_to_device,
)


__snake_case												=							namedtuple('''ExampleNamedTuple''', '''a b c''')


class      __lowerCamelCase	(       unittest.TestCase					):

     '''simple docstring'''


     def 				_UpperCAmelCase   (   self				)							->				Dict:
          _a     						=					torch.randn(5     ,					2				)
          _a     						=					torch.device('''cuda'''				) if torch.cuda.is_available() else torch.device('''cpu'''				)

          _a     						=					send_to_device(__UpperCAmelCase     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta.cpu()     ,					__UpperCAmelCase				)				)

          _a     						=					send_to_device((tensor, [tensor, tensor], 1)     ,					__UpperCAmelCase				)
          self.assertIsInstance(__UpperCAmelCase     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta[0].cpu()     ,					__UpperCAmelCase				)				)
          self.assertIsInstance(resulta[1]     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta[1][0].cpu()     ,					__UpperCAmelCase				)				)
          self.assertTrue(torch.equal(resulta[1][1].cpu()     ,					__UpperCAmelCase				)				)
          self.assertEqual(resulta[2]     ,					1				)

          _a     						=					send_to_device({'''a''': tensor, '''b''': [tensor, tensor], '''c''': 1}     ,					__UpperCAmelCase				)
          self.assertIsInstance(__UpperCAmelCase     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta['''a'''].cpu()     ,					__UpperCAmelCase				)				)
          self.assertIsInstance(resulta['''b''']     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta['''b'''][0].cpu()     ,					__UpperCAmelCase				)				)
          self.assertTrue(torch.equal(resulta['''b'''][1].cpu()     ,					__UpperCAmelCase				)				)
          self.assertEqual(resulta['''c''']     ,					1				)

          _a     						=					send_to_device(ExampleNamedTuple(a=__UpperCAmelCase     ,					b=[tensor, tensor]     ,					c=1				)     ,					__UpperCAmelCase				)
          self.assertIsInstance(__UpperCAmelCase     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta.a.cpu()     ,					__UpperCAmelCase				)				)
          self.assertIsInstance(resulta.b     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta.b[0].cpu()     ,					__UpperCAmelCase				)				)
          self.assertTrue(torch.equal(resulta.b[1].cpu()     ,					__UpperCAmelCase				)				)
          self.assertEqual(resulta.c     ,					1				)

          _a     						=					send_to_device(UserDict({'''a''': tensor, '''b''': [tensor, tensor], '''c''': 1}				)     ,					__UpperCAmelCase				)
          self.assertIsInstance(__UpperCAmelCase     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta['''a'''].cpu()     ,					__UpperCAmelCase				)				)
          self.assertIsInstance(resulta['''b''']     ,					__UpperCAmelCase				)
          self.assertTrue(torch.equal(resulta['''b'''][0].cpu()     ,					__UpperCAmelCase				)				)
          self.assertTrue(torch.equal(resulta['''b'''][1].cpu()     ,					__UpperCAmelCase				)				)
          self.assertEqual(resulta['''c''']     ,					1				)


     def 				_UpperCAmelCase   (   self				)							->				Optional[int]:
          with self.assertRaises(__UpperCAmelCase				) as cm:
               _a     						=					recursively_apply(torch.tensor     ,					(torch.tensor(1				), 1)     ,					error_on_other_type=__UpperCAmelCase				)
          self.assertEqual(
              str(cm.exception				)     ,					'''Unsupported types (<class \'int\'>) passed to `tensor`. Only nested list/tuple/dicts of objects that are valid for `is_torch_tensor` should be passed.'''     ,					)


     def 				_UpperCAmelCase   (   self				)							->				Optional[int]:
          _a     						=					torch.tensor([1, 2, 3, 4, 5]				)
          self.assertEqual(listify(__UpperCAmelCase				)     ,					[1, 2, 3, 4, 5]				)

          _a     						=					torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]				)
          self.assertEqual(listify(__UpperCAmelCase				)     ,					[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]				)

          _a     						=					torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]				)
          self.assertEqual(
              listify(__UpperCAmelCase				)     ,					[[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]				)


     def 				_UpperCAmelCase   (   self				)							->				List[str]:
          with patch_environment(aa=1     ,					BB=2				):
               self.assertEqual(os.environ.get('''AA'''				)     ,					'''1'''				)
               self.assertEqual(os.environ.get('''BB'''				)     ,					'''2'''				)

          self.assertNotIn('''AA'''     ,					os.environ				)
          self.assertNotIn('''BB'''     ,					os.environ				)


     def 				_UpperCAmelCase   (   self				)							->				List[str]:
          _a     						=					RegressionModel()
          _a     						=					model.forward
          _a     						=					convert_outputs_to_fpaa(model.forward				)
          _a     						=					extract_model_from_parallel(__UpperCAmelCase     ,					keep_fpaa_wrapper=__UpperCAmelCase				)
          _a     						=					pickle.dumps(__UpperCAmelCase				)


     @require_cuda
     def 				_UpperCAmelCase   (   self				)							->				Optional[Any]:
          _a     						=					RegressionModel()
          _a     						=					model.forward
          _a     						=					torch.cuda.amp.autocast(dtype=torch.floataa				)(model.forward				)
          _a     						=					convert_outputs_to_fpaa(model.forward				)
          _a     						=					extract_model_from_parallel(__UpperCAmelCase     ,					keep_fpaa_wrapper=__UpperCAmelCase				)
          _a     						=					pickle.dumps(__UpperCAmelCase				)


     @require_cuda
     @require_torch_min_version(version='''2.0'''				)
     def 				_UpperCAmelCase   (   self				)							->				int:
          _a     						=					RegressionModel()
          _a     						=					model.forward
          _a     						=					torch.cuda.amp.autocast(dtype=torch.floataa				)(model.forward				)
          _a     						=					convert_outputs_to_fpaa(model.forward				)
          _a     						=					torch.compile(model.forward     ,					backend='''inductor'''				)
          _a     						=					torch.randn(4     ,					10				).cuda()
          _a     						=					model(__UpperCAmelCase				)


     def 				_UpperCAmelCase   (   self				)							->				Optional[Any]:
          _a     						=					RegressionModel()
          # could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
          _a     						=					torch.nn.parallel.DataParallel(__UpperCAmelCase				)
          _a     						=					extract_model_from_parallel(__UpperCAmelCase				)

          self.assertEqual(__UpperCAmelCase     ,					__UpperCAmelCase				)


     @require_torch_min_version(version='''2.0'''				)
     def 				_UpperCAmelCase   (   self				)							->				str:
          _a     						=					RegressionModel()
          _a     						=					torch.compile(__UpperCAmelCase				)

          # could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
          _a     						=					torch.nn.parallel.DataParallel(__UpperCAmelCase				)
          _a     						=					torch.compile(__UpperCAmelCase				)
          _a     						=					extract_model_from_parallel(__UpperCAmelCase				)

          self.assertEqual(compiled_model._orig_mod     ,					compiled_model_unwrapped._orig_mod				)





     def 				_UpperCAmelCase   (   self				)							->				str:
          self.assertEqual(find_device([1, '''a''', torch.tensor([1, 2, 3]				)]				)     ,					torch.device('''cpu'''				)				)
          self.assertEqual(find_device({'''a''': 1, '''b''': torch.tensor([1, 2, 3]				)}				)     ,					torch.device('''cpu'''				)				)
          self.assertIsNone(find_device([1, '''a''']				)				)



"""simple docstring"""






def    A_ ( _lowerCAmelCase  :       str,  _lowerCAmelCase  :       str							):






     """simple docstring"""

     if len(_lowerCAmelCase							) < len(_lowerCAmelCase							):
          return levenshtein_distance(_lowerCAmelCase,  _lowerCAmelCase							)

     if len(_lowerCAmelCase							) == 0:
          return len(_lowerCAmelCase							)

     _a     						=					list(range(len(_lowerCAmelCase							) + 1							)							)

     for i, ca in enumerate(_lowerCAmelCase							):
          _a     						=					[i + 1]

          for j, ca in enumerate(_lowerCAmelCase							):
               # Calculate insertions, deletions and substitutions
               _a     						=					previous_row[j + 1] + 1
               _a     						=					current_row[j] + 1
               _a     						=					previous_row[j] + (ca != ca)

               # Get the minimum to append to the current row
               current_row.append(min(_lowerCAmelCase,  _lowerCAmelCase,  _lowerCAmelCase							)							)

          # Store the previous row
          _a     						=					current_row

     # Returns the last element (distance)
     return previous_row[-1]


if __name__ == "__main__":
   __snake_case												=							input('''Enter the first word:\n''').strip()
   __snake_case												=							input('''Enter the second word:\n''').strip()

   __snake_case												=							levenshtein_distance(first_word, second_word)
   print(f'Levenshtein distance between {first_word} and {second_word} is {result}')