Make interfaces use abstract class api

src/annotations/annotations.py

-from dataclasses import dataclass
-
-
-@dataclass
 class Annotation:
     def __hash__(self) -> int:
         return (type(self), *(self.__dict__.values())).__hash__()

src/detections/detection.py

-from dataclasses import dataclass
 from typing import Optional
 
 
-@dataclass
 class Detection:
     TYPE_NAME = "detection"
 

src/detectors/interface.py

 from typing import List, Dict, Any, Tuple
 from src.detections import Detection
+from abc import ABC, abstractmethod
 
-
-class Detector:
+class Detector(ABC):
+    @abstractmethod
     def detect(
         self, text: str, annotations: Dict[str, List[Tuple[int, int, Any]]]
     ) -> List[Tuple[int, int, Detection]]:
-        raise NotImplementedError
+        """Detects entities in text
+
+        Args:
+            text (str): Text to be processed.
+            annotations (Dict[str, List[Tuple[int, int, Any]]]): Annotations.
+
+        Returns:
+            List[Tuple[int, int, Detection]]: List of detections.
+        """
+        pass
\ No newline at end of file

src/dictionaries/morphosyntactic/interface.py

 from src.detections import Detection
 from typing import Optional, List, Type
+from abc import ABC, abstractmethod
 
-
-class MorphosyntacticDictionary:
+class MorphosyntacticDictionary(ABC):
+    @abstractmethod
     def get_supported_detection_classes(self) -> List[Type[Detection]]:
         """
-        Returns a list of supported detection classes
+        Returns a list of supported detection classess
         """
-        raise NotImplementedError()
+        pass
 
     def get_random_replacement(self, original_entry: Detection) -> Optional[str]:
         """
         Returns a random replacement for the original entry
         """
-        raise NotImplementedError()
+        pass

src/input_parsers/interface.py

 from typing import Dict, List, Tuple, Any
+from abc import ABC, abstractmethod
 
 
-class InputParser:
+class InputParser(ABC):
+    @abstractmethod
     def parse(self, content: str) -> Tuple[str, List[Tuple[int, int, Any]]]:
         """Parse input string into text and annotations.
 

src/pipeline/default.py

@@ -19,8 +19,8 @@ class DefaultPipeline(Pipeline):
         self._suppressor = suppressor
         self._replacers = replacers
 
-    def run(self, input) -> str:
-        with open(input, "r") as f:
+    def run(self, input_path) -> str:
+        with open(input_path, "r") as f:
             content = f.read()
         parsed_input = self._input_parser.parse(content)
 

src/pipeline/interface.py

-class Pipeline:
-    def run(self, input) -> str:
-        raise NotImplementedError
+from abc import ABC, abstractmethod
+
+class Pipeline(ABC):
+    @abstractmethod
+    def run(self, input_path) -> str:
+        """Run the whole anonymization pipeline on the input file and output the result.
+
+        Args:
+            input_path (_type_): Path to the input file.
+
+        Returns:
+            str: Anonymized text. 
+        """
+        pass

src/pipeline/sequential_jsonl.py

@@ -20,9 +20,9 @@ class SequentialJSONLPipeline(Pipeline):
         self._suppressor = suppressor
         self._replacers = replacers
 
-    def run(self, input) -> str:
+    def run(self, input_path) -> str:
         result = []
-        with open(input, "r") as f:
+        with open(input_path, "r") as f:
             for line in f.readlines():
                 if line.strip() == "":
                     continue

src/suppressors/interface.py

 from typing import List, Tuple, Any
+from abc import ABC, abstractmethod
 
 
-class Suppressor:
+class Suppressor(ABC):
+    @abstractmethod
     def suppress(
         self, annotations: List[Tuple[int, int, Any]]
     ) -> List[Tuple[int, int, Any]]: