Create an entrypoint and split code up

The aste file that is produced by this matches the notebook output

src/alignment.py

@@ -0,0 +1,165 @@
+from dataclasses import asdict
+from typing import Optional
+
+import Levenshtein
+import pandas as pd
+
+from .types import CharacterIndices, Triplet, WordSpans
+
+
+def find_closest_text(
+    *,
+    original: pd.Series,
+    replacement: pd.Series,
+) -> pd.Series:
+    # Returns a series of the replacement values aligned to the original values
+    no_space_replacements = {text.replace(" ", ""): text for text in replacement}
+    result = original.str.replace(" ", "").map(no_space_replacements)
+    non_perfect_matches = result.isna().sum()
+
+    assert non_perfect_matches / len(original) <= 0.05, (
+        "Poor alignment with replacement text. "
+        f"{non_perfect_matches:,} of {len(original),} rows did not match well"
+    )
+
+    def closest(text: str) -> str:
+        distances = replacement.apply(
+            lambda comparison: Levenshtein.distance(text, comparison)
+        )
+        return replacement.iloc[distances.argmin()]
+
+    result.loc[result.isna()] = result[result.isna()].apply(closest)
+    return result
+
+
+def to_character_indices_series(row: pd.Series) -> pd.Series:
+    result = to_character_indices(triplet=row.triples, text=row.text)
+    return pd.Series(asdict(result))
+
+
+def to_character_indices(
+    *,
+    triplet: Triplet,
+    text: str,
+) -> CharacterIndices:
+    aspect_span, opinion_span, _ = triplet
+    assert _is_sequential(aspect_span), f"aspect span not sequential: {aspect_span}"
+    assert _is_sequential(opinion_span), f"opinion span not sequential: {opinion_span}"
+
+    spans = WordSpans.make(text)
+
+    aspect_start_index, aspect_end_index = spans.to_indices(aspect_span)
+    aspect_term = text[aspect_start_index : aspect_end_index + 1]
+    opinion_start_index, opinion_end_index = spans.to_indices(opinion_span)
+    opinion_term = text[opinion_start_index : opinion_end_index + 1]
+
+    return CharacterIndices(
+        aspect_start_index=aspect_start_index,
+        aspect_end_index=aspect_end_index,
+        aspect_term=aspect_term,
+        opinion_start_index=opinion_start_index,
+        opinion_end_index=opinion_end_index,
+        opinion_term=opinion_term,
+    )
+
+
+def to_aligned_character_indices(
+    *,
+    original: str,
+    replacement: str,
+    original_indices: CharacterIndices,
+) -> CharacterIndices:
+    indices = _aligned_character_indices(original=original, replacement=replacement)
+
+    aspect_start_index = _aligned_start_index(
+        text=replacement,
+        original_index=original_indices.aspect_start_index,
+        indices=indices,
+    )
+    aspect_end_index = _aligned_end_index(
+        text=replacement,
+        original_index=original_indices.aspect_end_index,
+        indices=indices,
+    )
+    aspect_term = replacement[aspect_start_index : aspect_end_index + 1]
+
+    opinion_start_index = _aligned_start_index(
+        text=replacement,
+        original_index=original_indices.opinion_start_index,
+        indices=indices,
+    )
+    opinion_end_index = _aligned_end_index(
+        text=replacement,
+        original_index=original_indices.opinion_end_index,
+        indices=indices,
+    )
+    opinion_term = replacement[opinion_start_index : opinion_end_index + 1]
+
+    return CharacterIndices(
+        aspect_start_index=aspect_start_index,
+        aspect_end_index=aspect_end_index,
+        aspect_term=aspect_term,
+        opinion_start_index=opinion_start_index,
+        opinion_end_index=opinion_end_index,
+        opinion_term=opinion_term,
+    )
+
+
+def _is_sequential(span: tuple[int, ...]) -> bool:
+    return all(span[index + 1] - span[index] == 1 for index in range(len(span) - 1))
+
+
+def _aligned_character_indices(original: str, replacement: str) -> list[Optional[int]]:
+    indices: list[Optional[int]] = list(range(len(original)))
+    for operation, _source_position, destination_position in Levenshtein.editops(
+        original, replacement
+    ):
+        if operation == "replace":
+            indices[destination_position] = None
+        elif operation == "insert":
+            indices.insert(destination_position, None)
+        elif operation == "delete":
+            del indices[destination_position]
+    return indices
+
+
+def _aligned_start_index(
+    text: str, original_index: int, indices: list[Optional[int]]
+) -> int:
+    closest_after = min(
+        index for index in indices if index is not None and index >= original_index
+    )
+    index = indices.index(closest_after)
+
+    # Not every character in the original text is aligned to a character in the
+    # replacement text. The replacement text may have deleted it, or replaced
+    # it. Can step back through each letter until the word boundary is found or
+    # an aligned character is found.
+    while index > 0:
+        if indices[index - 1] is not None:
+            break
+        if text[index - 1] == " ":
+            break
+        index -= 1
+    return index
+
+
+def _aligned_end_index(
+    text: str, original_index: int, indices: list[Optional[int]]
+) -> int:
+    closest_before = min(
+        index for index in indices if index is not None and index <= original_index
+    )
+    index = indices.index(closest_before)
+
+    # Not every character in the original text is aligned to a character in the
+    # replacement text. The replacement text may have deleted it, or replaced
+    # it. Can step back through each letter until the word boundary is found or
+    # an aligned character is found.
+    while index < len(indices) - 1:
+        if indices[index + 1] is not None:
+            break
+        if text[index + 1] == " ":
+            break
+        index += 1
+    return index

src/convert.py

@@ -263,3 +263,14 @@ def aste_to_character_indices(
         opinion_term=opinion_term,
         sentiment=nice_sentiment,
     )
+
+
+label_to_sentiment = {
+    "POS": "positive",
+    "NEG": "negative",
+    "NEU": "neutral",
+}
+
+
+def to_nice_sentiment(label: str) -> str:
+    return label_to_sentiment[sentiment]

src/main.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .alignment import to_character_indices_series
+from .data import read_aste_file
+from .sentiment import to_nice_sentiment
+
+app = typer.Typer()
+
+
+@app.command()
+def aste(
+    aste_file: Annotated[Path, typer.Option()],
+    output_file: Annotated[Path, typer.Option()],
+) -> None:
+    df = read_aste_file(aste_file)
+    df = df.explode("triples")
+    df = df.reset_index(drop=False)
+    df = df.merge(
+        df.apply(to_character_indices_series, axis="columns"),
+        left_index=True,
+        right_index=True,
+    )
+    df["sentiment"] = df.triples.apply(lambda triple: to_nice_sentiment(triple[2]))
+    df = df.drop(columns=["triples"])
+
+    print(df.sample(3))
+
+    df.to_parquet(output_file, compression="gzip")
+
+
+@app.command()
+def sem_eval(
+    aste_file: Annotated[Path, typer.Option()],
+    sem_eval_file: Annotated[Path, typer.Option()],
+    output_file: Annotated[Path, typer.Option()],
+) -> None:
+    pass
+
+
+if __name__ == "__main__":
+    app()

src/sentiment.py

@@ -0,0 +1,9 @@
+label_to_sentiment = {
+    "POS": "positive",
+    "NEG": "negative",
+    "NEU": "neutral",
+}
+
+
+def to_nice_sentiment(label: str) -> str:
+    return label_to_sentiment[label]

src/types.py

@@ -2,6 +2,12 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from typing import Literal
+
+AspectWordIndices = tuple[int, ...]
+OpinionWordIndices = tuple[int, ...]
+Sentiment = Literal["NEG", "NEU", "POS"]
+Triplet = tuple[AspectWordIndices, OpinionWordIndices, Sentiment]
 
 word_pattern = re.compile(r"\S+")
 
@@ -11,12 +17,27 @@ class WordSpan:
     start_index: int
     end_index: int  # this is the letter after the end
 
+
+@dataclass
+class WordSpans:
+    spans: list[WordSpan]
+
     @staticmethod
-    def to_spans(text: str) -> list[WordSpan]:
-        return [
+    def make(text: str) -> WordSpans:
+        spans = [
             WordSpan(start_index=match.start(), end_index=match.end())
             for match in word_pattern.finditer(text)
         ]
+        return WordSpans(spans)
+
+    def to_indices(self, span: tuple[int, ...]) -> tuple[int, int]:
+        word_start = span[0]
+        word_start_span = self.spans[word_start]
+
+        word_end = span[-1]
+        word_end_span = self.spans[word_end]
+
+        return word_start_span.start_index, word_end_span.end_index - 1
 
 
 @dataclass(frozen=True)
@@ -27,4 +48,3 @@ class CharacterIndices:
     opinion_start_index: int
     opinion_end_index: int
     opinion_term: str
-    sentiment: str