feat: creation of a differ abstract base class (#1116)

Closes #1113 

### Summary of Changes
added an abstract differ base class called `AbstractDiffer` in new
package `package_parser.migration` with the methods:

- `compute_class_similarity`
- `compute_attribute_similarity`
- `compute_function_similarity`
- `compute_parameter_similarity`
- `compute_result_similarity`

They should return a value between 0 and 1. The closer the returned
value is to 1, the more similar the parameters are.

### Testing Instructions
Not (yet) used as an abstract class - see the rewritten class

Co-authored-by: Aclrian <[email protected]>
Co-authored-by: Lars Reimann <[email protected]>

Author: Aclrian

data/api/sklearn__api.json

@@ -1,6 +1,6 @@
 import logging
 import re
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import astroid
 from astroid import NodeNG
@@ -13,12 +13,15 @@
     Function,
     Import,
     Module,
+    NamedType,
+    UnionType,
 )
 from package_parser.utils import parent_qualified_name
 
 from ._file_filters import _is_init_file
 from ._get_parameter_list import get_parameter_list
 from .documentation_parsing import AbstractDocumentationParser
+from .model._api import Attribute
 
 
 def trim_code(code, from_line_no, to_line_no, encoding):
@@ -141,9 +144,53 @@ def leave_module(self, _: astroid.Module) -> None:
 
         self.api.add_module(module)
 
+    @staticmethod
+    def get_type_of_attribute(infered_value: Any) -> Optional[str]:
+        if infered_value == astroid.Uninferable:
+            return None
+        if isinstance(infered_value, astroid.Const) and infered_value.value is None:
+            return None
+        if isinstance(infered_value, astroid.List):
+            return "list"
+        if isinstance(infered_value, astroid.Dict):
+            return "dict"
+        if isinstance(infered_value, astroid.ClassDef):
+            return "type"
+        if isinstance(infered_value, astroid.Tuple):
+            return "tuple"
+        if isinstance(infered_value, (astroid.FunctionDef, astroid.Lambda)):
+            return "Callable"
+        if isinstance(infered_value, astroid.Const):
+            return infered_value.value.__class__.__name__
+        if isinstance(infered_value, astroid.Instance):
+            return infered_value.name
+        return None
+
+    @staticmethod
+    def get_instance_attributes(instance_attributes: dict[str, Any]) -> list[Attribute]:
+        attributes = []
+        for name, assignments in instance_attributes.items():
+            types = set()
+            for assignment in assignments:
+                if isinstance(assignment, astroid.AssignAttr) and isinstance(
+                    assignment.parent, astroid.Assign
+                ):
+                    attribute_type = _AstVisitor.get_type_of_attribute(
+                        next(astroid.inference.infer_attribute(self=assignment))
+                    )
+                    if attribute_type is not None:
+                        types.add(attribute_type)
+            if len(types) == 1:
+                attributes.append(Attribute(name, NamedType(types.pop())))
+            if len(types) > 1:
+                attributes.append(
+                    Attribute(name, UnionType([NamedType(type_) for type_ in types]))
+                )
+        return attributes
+
     def enter_classdef(self, class_node: astroid.ClassDef) -> None:
         qname = class_node.qname()
-        instance_attributes = list(class_node.instance_attrs)
+        instance_attributes = self.get_instance_attributes(class_node.instance_attrs)
 
         decorators: Optional[astroid.Decorators] = class_node.decorators
         if decorators is not None:

package-parser/package_parser/processing/api/_ast_visitor.py

@@ -1,6 +1,7 @@
 from ._api import (
     API,
     API_SCHEMA_VERSION,
+    Attribute,
     Class,
     FromImport,
     Function,

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

@@ -7,6 +7,7 @@
 
 from ._documentation import ClassDocumentation, FunctionDocumentation
 from ._parameters import Parameter
+from ._types import AbstractType
 
 API_SCHEMA_VERSION = 1
 
@@ -207,7 +208,10 @@ def from_json(json: Any) -> Class:
                 full_docstring=json.get("docstring", ""),
             ),
             json.get("code", ""),
-            json.get("instance_attributes", []),
+            [
+                Attribute.from_json(instance_attribute)
+                for instance_attribute in json.get("instance_attributes", [])
+            ],
         )
 
         for method_id in json["methods"]:
@@ -225,7 +229,7 @@ def __init__(
         reexported_by: list[str],
         documentation: ClassDocumentation,
         code: str,
-        instance_attributes: list[str],
+        instance_attributes: list[Attribute],
     ) -> None:
         self.id: str = id_
         self.qname: str = qname
@@ -258,10 +262,26 @@ def to_json(self) -> Any:
             "description": self.documentation.description,
             "docstring": self.documentation.full_docstring,
             "code": self.code,
-            "instance_attributes": self.instance_attributes,
+            "instance_attributes": [
+                attribute.to_json() for attribute in self.instance_attributes
+            ],
         }
 
 
+@dataclass
+class Attribute:
+    name: str
+    types: Optional[AbstractType]
+
+    def to_json(self) -> dict[str, Any]:
+        types_json = self.types.to_json() if self.types is not None else ""
+        return {"name": self.name, "types": types_json}
+
+    @staticmethod
+    def from_json(json: Any) -> Attribute:
+        return Attribute(json["name"], AbstractType.from_json(json["types"]))
+
+
 @dataclass
 class Function:
     id: str

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

@@ -13,11 +13,31 @@ class AbstractType(metaclass=ABCMeta):
     def to_json(self):
         pass
 
+    @classmethod
+    def from_json(cls, json: Any) -> Optional[AbstractType]:
+        value: Optional[AbstractType] = NamedType.from_json(json)
+        if value is not None:
+            return value
+        value = EnumType.from_json(json)
+        if value is not None:
+            return value
+        value = BoundaryType.from_json(json)
+        if value is not None:
+            return value
+        value = UnionType.from_json(json)
+        return value
+
 
 @dataclass
 class NamedType(AbstractType):
     name: str
 
+    @classmethod
+    def from_json(cls, json: Any) -> Optional[NamedType]:
+        if json["kind"] == cls.__class__.__name__:
+            return NamedType(json["name"])
+        return None
+
     @classmethod
     def from_string(cls, string: str) -> NamedType:
         return NamedType(string)
@@ -31,6 +51,12 @@ class EnumType(AbstractType):
     values: set[str] = field(default_factory=set)
     full_match: str = ""
 
+    @classmethod
+    def from_json(cls, json: Any) -> Optional[EnumType]:
+        if json["kind"] == cls.__class__.__name__:
+            return EnumType(json["values"])
+        return None
+
     @classmethod
     def from_string(cls, string: str) -> Optional[EnumType]:
         def remove_backslash(e: str):
@@ -88,12 +114,23 @@ class BoundaryType(AbstractType):
 
     @classmethod
     def _is_inclusive(cls, bracket: str) -> bool:
-        if bracket == "(" or bracket == ")":
+        if bracket in ("(", ")"):
             return False
-        elif bracket == "[" or bracket == "]":
+        if bracket in ("[", "]"):
             return True
-        else:
-            raise Exception(f"{bracket} is not one of []()")
+        raise Exception(f"{bracket} is not one of []()")
+
+    @classmethod
+    def from_json(cls, json: Any) -> Optional[BoundaryType]:
+        if json["kind"] == cls.__class__.__name__:
+            return BoundaryType(
+                json["base_type"],
+                json["min"],
+                json["max"],
+                json["min_inclusive"],
+                json["max_inclusive"],
+            )
+        return None
 
     @classmethod
     def from_string(cls, string: str) -> Optional[BoundaryType]:
@@ -154,12 +191,8 @@ def __eq__(self, __o: object) -> bool:
             if eq:
                 if self.max == BoundaryType.INFINITY:
                     return True
-                else:
-                    return self.max_inclusive == __o.max_inclusive
-            else:
-                return False
-        else:
-            return False
+                return self.max_inclusive == __o.max_inclusive
+        return False
 
     def to_json(self) -> dict[str, Any]:
         return {
@@ -176,6 +209,17 @@ def to_json(self) -> dict[str, Any]:
 class UnionType(AbstractType):
     types: list[AbstractType]
 
+    @classmethod
+    def from_json(cls, json: Any) -> Optional[UnionType]:
+        if json["kind"] == cls.__class__.__name__:
+            types = []
+            for element in json["types"]:
+                type_ = AbstractType.from_json(element)
+                if type_ is not None:
+                    types.append(type_)
+            return UnionType(types)
+        return None
+
     def to_json(self) -> dict[str, Any]:
         type_list = []
         for t in self.types:
@@ -188,7 +232,7 @@ def create_type(
     parameter_documentation: ParameterDocumentation,
 ) -> Optional[AbstractType]:
     type_string = parameter_documentation.type
-    types: list[AbstractType] = list()
+    types: list[AbstractType] = []
 
     # Collapse whitespaces
     type_string = re.sub(r"\s+", " ", type_string)
@@ -248,7 +292,6 @@ def create_type(
 
     if len(types) == 1:
         return types[0]
-    elif len(types) == 0:
+    if len(types) == 0:
         return None
-    else:
-        return UnionType(types)
+    return UnionType(types)

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

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+from package_parser.processing.api.model import (
+    Attribute,
+    Class,
+    Function,
+    Parameter,
+    Result,
+)
+
+
+class AbstractDiffer(ABC):
+    @abstractmethod
+    def compute_attribute_similarity(
+        self,
+        attributes_a: Attribute,
+        attributes_b: Attribute,
+    ) -> float:
+        pass
+
+    @abstractmethod
+    def compute_class_similarity(self, class_a: Class, class_b: Class) -> float:
+        pass
+
+    @abstractmethod
+    def compute_function_similarity(
+        self, function_a: Function, function_b: Function
+    ) -> float:
+        pass
+
+    @abstractmethod
+    def compute_parameter_similarity(
+        self, parameter_a: Parameter, parameter_b: Parameter
+    ) -> float:
+        pass
+
+    @abstractmethod
+    def compute_result_similarity(self, result_a: Result, result_b: Result) -> float:
+        pass