Kylel/2023/hardening codebase

src/mmda/eval/metrics.py

@@ -75,11 +75,11 @@ def levenshtein(
 
 def box_overlap(box: Box, container: Box) -> float:
     """Returns the percentage of area of a box inside of a container."""
-    bl, bt, bw, bh = box.xywh
+    bl, bt, bw, bh = box.l, box.t, box.w, box.h
     br = bl + bw
     bb = bt + bh
 
-    cl, ct, cw, ch = container.xywh
+    cl, ct, cw, ch = container.l, container.t, container.w, container.h
     cr = cl + cw
     cb = ct + ch
 

src/mmda/predictors/sklearn_predictors/svm_word_predictor.py

@@ -451,7 +451,10 @@ def _create_words(
             else:
                 spans = [
                     Span.small_spans_to_big_span(
-                        spans=[span for token in tokens_in_word for span in token.spans]
+                        spans=[
+                            span for token in tokens_in_word for span in token.spans
+                        ],
+                        merge_boxes=False,
                     )
                 ]
                 metadata = (
@@ -471,7 +474,8 @@ def _create_words(
         # last bit
         spans = [
             Span.small_spans_to_big_span(
-                spans=[span for token in tokens_in_word for span in token.spans]
+                spans=[span for token in tokens_in_word for span in token.spans],
+                merge_boxes=False,
             )
         ]
         metadata = (

src/mmda/types/annotation.py

@@ -22,7 +22,6 @@
 __all__ = ["Annotation", "BoxGroup", "SpanGroup", "Relation"]
 
 
-
 def warn_deepcopy_of_annotation(obj: "Annotation") -> None:
     """Warns when a deepcopy is performed on an Annotation."""
 
@@ -34,15 +33,14 @@ def warn_deepcopy_of_annotation(obj: "Annotation") -> None:
     warnings.warn(msg, UserWarning, stacklevel=2)
 
 
-
 class Annotation:
     """Annotation is intended for storing model predictions for a document."""
 
     def __init__(
-            self,
-            id: Optional[int] = None,
-            doc: Optional['Document'] = None,
-            metadata: Optional[Metadata] = None
+        self,
+        id: Optional[int] = None,
+        doc: Optional["Document"] = None,
+        metadata: Optional[Metadata] = None,
     ):
         self.id = id
         self.doc = doc
@@ -77,40 +75,44 @@ def __getattr__(self, field: str) -> List["Annotation"]:
         return self.__getattribute__(field)
 
 
-
 class BoxGroup(Annotation):
     def __init__(
-            self,
-            boxes: List[Box],
-            id: Optional[int] = None,
-            doc: Optional['Document'] = None,
-            metadata: Optional[Metadata] = None,
+        self,
+        boxes: List[Box],
+        id: Optional[int] = None,
+        doc: Optional["Document"] = None,
+        metadata: Optional[Metadata] = None,
+        allow_overlap: Optional[bool] = False,
     ):
         self.boxes = boxes
+        if not allow_overlap:
+            clusters = Box.cluster_boxes(boxes=boxes)
+            if any([len(cluster) > 1 for cluster in clusters]):
+                raise ValueError(
+                    "BoxGroup does not allow overlapping boxes. "
+                    "Consider setting allow_overlap=True."
+                )
         super().__init__(id=id, doc=doc, metadata=metadata)
 
     def to_json(self) -> Dict:
         box_group_dict = dict(
             boxes=[box.to_json() for box in self.boxes],
             id=self.id,
-            metadata=self.metadata.to_json()
+            metadata=self.metadata.to_json(),
         )
         return {
             key: value for key, value in box_group_dict.items() if value
         }  # only serialize non-null values
 
     @classmethod
     def from_json(cls, box_group_dict: Dict) -> "BoxGroup":
-
         if "metadata" in box_group_dict:
             metadata_dict = box_group_dict["metadata"]
         else:
             # this fallback is necessary to ensure compatibility with box
             # groups that were create before the metadata migration and
             # therefore have "type" in the root of the json dict instead.
-            metadata_dict = {
-                "type": box_group_dict.get("type", None)
-            }
+            metadata_dict = {"type": box_group_dict.get("type", None)}
 
         return cls(
             boxes=[
@@ -132,7 +134,7 @@ def __deepcopy__(self, memo):
         box_group = BoxGroup(
             boxes=deepcopy(self.boxes, memo),
             id=self.id,
-            metadata=deepcopy(self.metadata, memo)
+            metadata=deepcopy(self.metadata, memo),
         )
 
         # Don't copy an attached document
@@ -150,25 +152,30 @@ def type(self, type: Union[str, None]) -> None:
 
 
 class SpanGroup(Annotation):
-
     def __init__(
-            self,
-            spans: List[Span],
-            box_group: Optional[BoxGroup] = None,
-            id: Optional[int] = None,
-            doc: Optional['Document'] = None,
-            metadata: Optional[Metadata] = None,
+        self,
+        spans: List[Span],
+        box_group: Optional[BoxGroup] = None,
+        id: Optional[int] = None,
+        doc: Optional["Document"] = None,
+        metadata: Optional[Metadata] = None,
+        allow_overlap: Optional[bool] = False,
     ):
         self.spans = spans
+        if not allow_overlap:
+            clusters = Span.cluster_spans(spans=spans)
+            if any([len(cluster) > 1 for cluster in clusters]):
+                raise ValueError(
+                    "SpanGroup does not allow overlapping spans. "
+                    "Consider setting allow_overlap=True."
+                )
         self.box_group = box_group
         super().__init__(id=id, doc=doc, metadata=metadata)
 
     @property
     def symbols(self) -> List[str]:
         if self.doc is not None:
-            return [
-                self.doc.symbols[span.start: span.end] for span in self.spans
-            ]
+            return [self.doc.symbols[span.start : span.end] for span in self.spans]
         else:
             return []
 
@@ -187,12 +194,10 @@ def to_json(self) -> Dict:
             spans=[span.to_json() for span in self.spans],
             id=self.id,
             metadata=self.metadata.to_json(),
-            box_group=self.box_group.to_json() if self.box_group else None
+            box_group=self.box_group.to_json() if self.box_group else None,
         )
         return {
-            key: value
-            for key, value in span_group_dict.items()
-            if value is not None
+            key: value for key, value in span_group_dict.items() if value is not None
         }  # only serialize non-null values
 
     @classmethod
@@ -211,7 +216,7 @@ def from_json(cls, span_group_dict: Dict) -> "SpanGroup":
             # therefore have "id", "type" in the root of the json dict instead.
             metadata_dict = {
                 "type": span_group_dict.get("type", None),
-                "text": span_group_dict.get("text", None)
+                "text": span_group_dict.get("text", None),
             }
 
         return cls(
@@ -256,7 +261,7 @@ def __deepcopy__(self, memo):
             spans=deepcopy(self.spans, memo),
             id=self.id,
             metadata=deepcopy(self.metadata, memo),
-            box_group=deepcopy(self.box_group, memo)
+            box_group=deepcopy(self.box_group, memo),
         )
 
         # Don't copy an attached document
@@ -284,6 +289,5 @@ def text(self, text: Union[str, None]) -> None:
         self.metadata.text = text
 
 
-
 class Relation(Annotation):
-    pass
+    pass