feat: Improve calculating of Levenshtein Distance (#1180)

Closes ##1179.

### Summary of Changes

add dependecy levenshtein and use its distance function in
name_similarity

### Testing Instructions

run `package-parser/tests/processing/migration/test_differ.py` in a
previous commit from the main branch and after this commit and compare the running time

Author: Aclrian

package-parser/package_parser/processing/api/model/_types.py

@@ -10,7 +10,7 @@
 
 class AbstractType(metaclass=ABCMeta):
     @abstractmethod
-    def to_json(self):
+    def to_json(self) -> dict[str, Any]:
         pass
 
     @classmethod
@@ -45,7 +45,7 @@ def from_string(cls, string: str) -> NamedType:
     def to_json(self) -> dict[str, str]:
         return {"kind": self.__class__.__name__, "name": self.name}
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, self.__class__):
             return self.name == other.name
         return False
@@ -64,7 +64,7 @@ def from_json(cls, json: Any) -> Optional[EnumType]:
 
     @classmethod
     def from_string(cls, string: str) -> Optional[EnumType]:
-        def remove_backslash(e: str):
+        def remove_backslash(e: str) -> str:
             e = e.replace(r"\"", '"')
             e = e.replace(r"\'", "'")
             return e
@@ -97,7 +97,7 @@ def remove_backslash(e: str):
 
         return None
 
-    def update(self, enum: EnumType):
+    def update(self, enum: EnumType) -> None:
         self.values.update(enum.values)
 
     def to_json(self) -> dict[str, Any]:

package-parser/package_parser/processing/migration/model/_differ.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
-from typing import Any, Optional
+from typing import Any, Callable, Optional
 
+from Levenshtein import distance
 from package_parser.processing.api.model import (
     AbstractType,
     Attribute,
@@ -44,7 +45,9 @@ def compute_result_similarity(self, result_a: Result, result_b: Result) -> float
 
 
 def distance_elements(
-    list_a: list[Any], list_b: list[Any], are_similar=lambda x, y: x == y
+    list_a: list[Any],
+    list_b: list[Any],
+    are_similar: Callable[[Any, Any], bool] = lambda x, y: x == y,
 ) -> float:
     if len(list_a) == 0:
         return len(list_b)
@@ -64,7 +67,7 @@ class SimpleDiffer(AbstractDiffer):
         ParameterAssignment, dict[ParameterAssignment, float]
     ]
 
-    def __init__(self):
+    def __init__(self) -> None:
         distance_between_implicit_and_explicit = 0.3
         distance_between_vararg_and_normal = 0.3
         distance_between_position_and_named = 0.3
@@ -173,9 +176,7 @@ def compute_class_similarity(self, class_a: Class, class_b: Class) -> float:
         return (name_similarity + attributes_similarity + code_similarity) / 3
 
     def _compute_name_similarity(self, name_a: str, name_b: str) -> float:
-        name_similarity = distance_elements([*name_a], [*name_b]) / max(
-            len(name_a), len(name_b), 1
-        )
+        name_similarity = distance(name_a, name_b) / max(len(name_a), len(name_b), 1)
         return 1 - name_similarity
 
     def compute_attribute_similarity(
@@ -208,7 +209,9 @@ def compute_function_similarity(
             function_a.name, function_b.name
         )
 
-        def are_parameters_similar(parameter_a: Parameter, parameter_b: Parameter):
+        def are_parameters_similar(
+            parameter_a: Parameter, parameter_b: Parameter
+        ) -> bool:
             return self.compute_parameter_similarity(parameter_a, parameter_b) == 1
 
         parameter_similarity = distance_elements(
@@ -258,7 +261,7 @@ def _compute_type_similarity(
 
         def are_types_similar(
             abstract_type_a: AbstractType, abstract_type_b: AbstractType
-        ):
+        ) -> bool:
             return abstract_type_a.to_json() == abstract_type_b.to_json()
 
         type_list_a = self._create_list_from_type(type_a)
@@ -268,7 +271,7 @@ def are_types_similar(
         ) / max(len(type_list_a), len(type_list_b), 1)
         return 1 - diff_elements
 
-    def _create_list_from_type(self, abstract_type: AbstractType):
+    def _create_list_from_type(self, abstract_type: AbstractType) -> list[AbstractType]:
         if isinstance(abstract_type, UnionType):
             return abstract_type.types
         return [abstract_type]