Drop the old convert code

That was from the blog and was a bit wip

src/convert.py

@@ -1,276 +0,0 @@
-from typing import Optional
-
-import Levenshtein
-import pandas as pd
-
-from .data import read_aste_file, read_sem_eval_file
-from .types import CharacterIndices, WordSpan
-
-
-def get_original_text(
-    aste_file: str,
-    sem_eval_file: str,
-    debug: bool = False,
-) -> pd.DataFrame:
-    approximate_matches = 0
-
-    def best_match(text: str) -> str:
-        comparison = text.replace(" ", "")
-        if comparison in comparison_to_text:
-            return comparison_to_text[comparison]
-
-        nonlocal approximate_matches
-        approximate_matches += 1
-        distances = sem_eval_comparison.apply(
-            lambda se_comparison: Levenshtein.distance(comparison, se_comparison)
-        )
-        best = sem_eval_df.iloc[distances.argmin()].text
-        return best
-
-    sem_eval_df = read_sem_eval_file(sem_eval_file)
-    sem_eval_comparison = sem_eval_df.text.str.replace(" ", "")
-    comparison_to_text = dict(zip(sem_eval_comparison, sem_eval_df.text))
-
-    aste_df = read_aste_file(aste_file)
-    aste_df = aste_df.rename(columns={"text": "preprocessed_text"})
-    aste_df["text"] = aste_df.preprocessed_text.apply(best_match)
-    if debug:
-        print(f"Read {len(aste_df):,} rows")
-        print(f"Had to use {approximate_matches:,} approximate matches")
-    return aste_df[["text", "preprocessed_text", "triples"]]
-
-
-def edit(original: str, preprocessed: str) -> list[Optional[int]]:
-    indices: list[Optional[int]] = list(range(len(preprocessed)))
-    for operation, _source_position, destination_position in Levenshtein.editops(
-        preprocessed, original
-    ):
-        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 has_unmapped(indicies: list[Optional[int]]) -> bool:
-    return any(index is None for index in indicies)
-
-
-def has_unmapped_non_space(row: pd.Series) -> bool:
-    letter_and_index: list[tuple[str, Optional[int]]] = list(
-        zip(row.text, row.text_indices)
-    )
-    return any(index is None for letter, index in letter_and_index if letter != " ")
-
-
-def row_to_character_indices(row: pd.Series) -> pd.Series:
-    try:
-        return pd.Series(
-            to_character_indices(
-                triplet=row.triples,
-                preprocessed=row.preprocessed_text,
-                text=row.text,
-                text_indices=row.text_indices,
-            )
-        )
-    except:
-        print(f"failed to process row {row.name}")
-        print(row)
-        raise
-
-
-def to_character_indices(
-    *,
-    triplet: tuple[tuple[int], tuple[int], str],
-    preprocessed: str,
-    text: str,
-    text_indices: list[Optional[int]],
-) -> CharacterIndices:
-    def find_start_index(span: WordSpan) -> int:
-        # the starting letter in the lookup can be missing or None
-        # this would cause a lookup failure
-        # to recover from this we can find the following letter index and backtrack
-        for index in range(span.start_index, span.end_index):
-            try:
-                text_index = text_indices.index(index)
-                for _ in range(index - span.start_index):
-                    if text_index - 1 <= 0:
-                        break
-                    if text_indices[text_index - 1] is not None:
-                        break
-                    text_index -= 1
-                return text_index
-            except ValueError:
-                pass
-                # not present in list
-        raise ValueError(f"cannot find any part of {span}")
-
-    def find_end_index(span: WordSpan) -> int:
-        # the ending letter in the lookup can be missing or None
-        # this would cause a lookup failure
-        # to recover from this we can find the preceding letter index and backtrack
-        for index in range(span.end_index - 1, span.start_index - 1, -1):
-            try:
-                text_index = text_indices.index(index)
-                for _ in range(span.end_index - index):
-                    if text_index + 1 >= len(text_indices):
-                        break
-                    if text_indices[text_index + 1] is not None:
-                        break
-                    text_index += 1
-                return text_index
-            except ValueError:
-                pass
-                # not present in list
-        raise ValueError(f"cannot find any part of {span}")
-
-    def to_indices(span: tuple[int]) -> tuple[int, int]:
-        word_start = span[0]
-        word_start_span = word_indices[word_start]
-
-        word_end = span[-1]
-        word_end_span = word_indices[word_end]
-
-        start_index = find_start_index(word_start_span)
-        end_index = find_end_index(word_end_span)
-        return start_index, end_index
-
-    aspect_span, opinion_span, sentiment = 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}"
-    assert sentiment in {"POS", "NEG", "NEU"}, f"unknown sentiment: {sentiment}"
-
-    word_indices = WordSpan.to_spans(preprocessed)
-
-    aspect_start_index, aspect_end_index = to_indices(aspect_span)
-    aspect_term = text[aspect_start_index : aspect_end_index + 1]
-    opinion_start_index, opinion_end_index = to_indices(opinion_span)
-    opinion_term = text[opinion_start_index : opinion_end_index + 1]
-
-    nice_sentiment = {
-        "POS": "positive",
-        "NEG": "negative",
-        "NEU": "neutral",
-    }[sentiment]
-
-    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,
-        sentiment=nice_sentiment,
-    )
-
-
-def convert_sem_eval_text(
-    aste_file: str,
-    sem_eval_file: str,
-    debug: bool = False,
-) -> pd.DataFrame:
-    df = get_original_text(
-        aste_file=aste_file,
-        sem_eval_file=sem_eval_file,
-        debug=debug,
-    )
-    df = df.explode("triples")
-    df = df.reset_index(drop=False)
-    df["text_indices"] = df.apply(
-        lambda row: edit(original=row.text, preprocessed=row.preprocessed_text),
-        axis="columns",
-    )
-    df = df.merge(
-        df.apply(row_to_character_indices, axis="columns"),
-        left_index=True,
-        right_index=True,
-    )
-    df = df.drop(columns=["preprocessed_text", "triples", "text_indices"])
-    return df
-
-
-def convert_aste_text(aste_file: str) -> pd.DataFrame:
-    df = read_aste_file(aste_file)
-    df = df.explode("triples")
-    df = df.reset_index(drop=False)
-    df = df.merge(
-        df.apply(aste_row_to_character_indices, axis="columns"),
-        left_index=True,
-        right_index=True,
-    )
-    df = df.drop(columns=["triples"])
-    return df
-
-
-def aste_row_to_character_indices(row: pd.Series) -> pd.Series:
-    try:
-        return pd.Series(
-            aste_to_character_indices(
-                triplet=row.triples,
-                text=row.text,
-            )
-        )
-    except:
-        print(f"failed to process row {row.name}")
-        print(row)
-        raise
-
-
-def is_sequential(span: tuple[int]) -> bool:
-    return all(span[index + 1] - span[index] == 1 for index in range(len(span) - 1))
-
-
-def aste_to_character_indices(
-    *,
-    triplet: tuple[tuple[int], tuple[int], str],
-    text: str,
-) -> CharacterIndices:
-    def to_indices(span: tuple[int]) -> tuple[int, int]:
-        word_start = span[0]
-        word_start_span = word_indices[word_start]
-
-        word_end = span[-1]
-        word_end_span = word_indices[word_end]
-
-        return word_start_span.start_index, word_end_span.end_index - 1
-
-    aspect_span, opinion_span, sentiment = 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}"
-    assert sentiment in {"POS", "NEG", "NEU"}, f"unknown sentiment: {sentiment}"
-
-    word_indices = WordSpan.to_spans(text)
-
-    aspect_start_index, aspect_end_index = to_indices(aspect_span)
-    aspect_term = text[aspect_start_index : aspect_end_index + 1]
-    opinion_start_index, opinion_end_index = to_indices(opinion_span)
-    opinion_term = text[opinion_start_index : opinion_end_index + 1]
-
-    nice_sentiment = {
-        "POS": "positive",
-        "NEG": "negative",
-        "NEU": "neutral",
-    }[sentiment]
-
-    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,
-        sentiment=nice_sentiment,
-    )
-
-
-label_to_sentiment = {
-    "POS": "positive",
-    "NEG": "negative",
-    "NEU": "neutral",
-}
-
-
-def to_nice_sentiment(label: str) -> str:
-    return label_to_sentiment[sentiment]