SYMBOL INDEX (197 symbols across 10 files)

FILE: aste/analysis.py
  function set_seed (line 22) | def set_seed(seed: int):
  function test_load (line 28) | def test_load(
  class Scorer (line 77) | class Scorer:
    method run (line 80) | def run(self, path_pred: str, path_gold: str) -> dict:
    method make_tuples (line 110) | def make_tuples(self, sent: Sentence) -> List[tuple]:
  class SentimentTripletScorer (line 114) | class SentimentTripletScorer(Scorer):
    method make_tuples (line 117) | def make_tuples(self, sent: Sentence) -> List[tuple]:
  class TripletScorer (line 121) | class TripletScorer(Scorer):
    method make_tuples (line 124) | def make_tuples(self, sent: Sentence) -> List[tuple]:
  class OpinionScorer (line 128) | class OpinionScorer(Scorer):
    method make_tuples (line 131) | def make_tuples(self, sent: Sentence) -> List[tuple]:
  class TargetScorer (line 135) | class TargetScorer(Scorer):
    method make_tuples (line 138) | def make_tuples(self, sent: Sentence) -> List[tuple]:
  class OrigScorer (line 142) | class OrigScorer(Scorer):
    method make_tuples (line 145) | def make_tuples(self, sent: Sentence) -> List[tuple]:
    method run (line 148) | def run(self, path_pred: str, path_gold: str) -> dict:
  function run_eval_domains (line 153) | def run_eval_domains(
  function test_scorer (line 180) | def test_scorer(path_pred: str, path_gold: str):

FILE: aste/data_utils.py
  class SplitEnum (line 22) | class SplitEnum(str, Enum):
  class LabelEnum (line 28) | class LabelEnum(str, Enum):
    method as_list (line 36) | def as_list(cls):
    method i_to_label (line 40) | def i_to_label(cls, i: int):
    method label_to_i (line 44) | def label_to_i(cls, label) -> int:
  class SentimentTriple (line 48) | class SentimentTriple(BaseModel):
    method make_dummy (line 56) | def make_dummy(cls):
    method opinion (line 60) | def opinion(self) -> Tuple[int, int]:
    method target (line 64) | def target(self) -> Tuple[int, int]:
    method from_raw_triple (line 68) | def from_raw_triple(cls, x: RawTriple):
    method to_raw_triple (line 88) | def to_raw_triple(self) -> RawTriple:
    method as_text (line 98) | def as_text(self, tokens: List[str]) -> str:
  class TripleHeuristic (line 104) | class TripleHeuristic(BaseModel):
    method run (line 106) | def run(
  class TagMaker (line 135) | class TagMaker(BaseModel):
    method run (line 137) | def run(spans: List[Span], labels: List[LabelEnum], num_tokens: int) -...
  class BioesTagMaker (line 141) | class BioesTagMaker(TagMaker):
    method run (line 143) | def run(spans: List[Span], labels: List[LabelEnum], num_tokens: int) -...
  class Sentence (line 158) | class Sentence(BaseModel):
    method extract_spans (line 167) | def extract_spans(self) -> List[Tuple[int, int, LabelEnum]]:
    method as_text (line 175) | def as_text(self) -> str:
    method from_line_format (line 185) | def from_line_format(cls, text: str):
    method to_line_format (line 204) | def to_line_format(self) -> str:
  class Data (line 224) | class Data(BaseModel):
    method load (line 233) | def load(self):
    method load_from_full_path (line 243) | def load_from_full_path(cls, path: str):
    method save_to_path (line 248) | def save_to_path(self, path: str):
    method analyze_spans (line 261) | def analyze_spans(self):
    method analyze_joined_spans (line 292) | def analyze_joined_spans(self):
    method analyze_tag_counts (line 314) | def analyze_tag_counts(self):
    method analyze_span_distance (line 327) | def analyze_span_distance(self):
    method analyze_opinion_labels (line 337) | def analyze_opinion_labels(self):
    method analyze_tag_score (line 355) | def analyze_tag_score(self):
    method analyze_ner (line 366) | def analyze_ner(self):
    method analyze_direction (line 384) | def analyze_direction(self):
    method analyze (line 411) | def analyze(self):
  function test_save_to_path (line 439) | def test_save_to_path(path: str = "aste/data/triplet_data/14lap/train.tx...
  function merge_data (line 451) | def merge_data(items: List[Data]) -> Data:
  class Result (line 459) | class Result(BaseModel):
  class ResultAnalyzer (line 474) | class ResultAnalyzer(BaseModel):
    method check_overlap (line 476) | def check_overlap(a_start: int, a_end: int, b_start: int, b_end: int) ...
    method run_sentence (line 480) | def run_sentence(pred: Sentence, gold: Sentence):
    method analyze_labels (line 496) | def analyze_labels(pred: List[Sentence], gold: List[Sentence]):
    method analyze_spans (line 511) | def analyze_spans(pred: List[Sentence], gold: List[Sentence]):
    method run (line 551) | def run(cls, pred: List[Sentence], gold: List[Sentence], print_limit=16):
  function test_merge (line 586) | def test_merge(root="aste/data/triplet_data"):

FILE: aste/utils.py
  class Shell (line 13) | class Shell(BaseModel):
    method format_kwargs (line 17) | def format_kwargs(cls, **kwargs) -> str:
    method run_command (line 25) | def run_command(self, command: str) -> str:
    method run (line 43) | def run(self, command: str, *args, **kwargs) -> str:
  function hash_text (line 49) | def hash_text(x: str) -> str:
  class Timer (line 53) | class Timer(BaseModel):
    method __enter__ (line 57) | def __enter__(self):
    method __exit__ (line 61) | def __exit__(self, exc_type, exc_val, exc_tb):
  class PickleSaver (line 66) | class PickleSaver(BaseModel):
    method dump (line 69) | def dump(self, obj):
    method load (line 75) | def load(self):
  class FlexiModel (line 81) | class FlexiModel(BaseModel):
    class Config (line 82) | class Config:
  function get_simple_stats (line 86) | def get_simple_stats(numbers: List[Union[int, float]]):
  function count_joins (line 94) | def count_joins(spans: Set[Tuple[int, int]]) -> int:
  function update_nested_dict (line 106) | def update_nested_dict(d: dict, k: str, v, i=0, sep="__"):
  function test_update_nested_dict (line 120) | def test_update_nested_dict():
  function clean_up_triplet_data (line 127) | def clean_up_triplet_data(path: str):
  function clean_up_many (line 139) | def clean_up_many(pattern: str = "data/triplet_data/*/*.txt"):
  function merge_data (line 145) | def merge_data(
  function safe_divide (line 168) | def safe_divide(a: float, b: float) -> float:

FILE: aste/wrapper.py
  class SpanModelDocument (line 20) | class SpanModelDocument(BaseModel):
    method is_valid (line 27) | def is_valid(self) -> bool:
    method from_sentence (line 31) | def from_sentence(cls, x: Sentence):
  class SpanModelPrediction (line 48) | class SpanModelPrediction(SpanModelDocument):
    method to_sentence (line 54) | def to_sentence(self) -> Sentence:
  class SpanModelData (line 73) | class SpanModelData(BaseModel):
    method read (line 79) | def read(cls, path: Path) -> List[SpanModelDocument]:
    method load (line 88) | def load(self):
    method dump (line 93) | def dump(self, path: Path, sep="\n"):
    method from_data (line 103) | def from_data(cls, x: Data):
  class SpanModel (line 109) | class SpanModel(BaseModel):
    method save_temp_data (line 114) | def save_temp_data(self, path_in: str, name: str, is_test: bool = Fals...
    method fit (line 130) | def fit(self, path_train: str, path_dev: str):
    method predict (line 154) | def predict(self, path_in: str, path_out: str):
    method score (line 195) | def score(cls, path_pred: str, path_gold: str) -> dict:
  function run_score (line 226) | def run_score(path_pred: str, path_gold: str) -> dict:
  function run_train (line 230) | def run_train(path_train: str, path_dev: str, save_dir: str, random_seed...
  function run_train_many (line 239) | def run_train_many(save_dir_template: str, random_seeds: List[int], **kw...
  function run_eval (line 245) | def run_eval(path_test: str, save_dir: str):
  function run_eval_many (line 255) | def run_eval_many(save_dir_template: str, random_seeds: List[int], **kwa...

FILE: span_model/data/dataset_readers/document.py
  function format_float (line 8) | def format_float(x):
  class SpanCrossesSentencesError (line 12) | class SpanCrossesSentencesError(ValueError):
  function get_sentence_of_span (line 16) | def get_sentence_of_span(span, sentence_starts, doc_tokens):
  class Dataset (line 32) | class Dataset:
    method __init__ (line 33) | def __init__(self, documents):
    method __getitem__ (line 36) | def __getitem__(self, i):
    method __len__ (line 39) | def __len__(self):
    method __repr__ (line 42) | def __repr__(self):
    method from_jsonl (line 46) | def from_jsonl(cls, fname):
    method to_jsonl (line 55) | def to_jsonl(self, fname):
  class Document (line 62) | class Document:
    method __init__ (line 63) | def __init__(
    method from_json (line 76) | def from_json(cls, js):
    method _check_fields (line 112) | def _check_fields(js):
    method to_json (line 128) | def to_json(self):
    method split (line 141) | def split(self, max_tokens_per_doc):
    method __repr__ (line 196) | def __repr__(self):
    method __getitem__ (line 204) | def __getitem__(self, ix):
    method __len__ (line 207) | def __len__(self):
    method print_plaintext (line 210) | def print_plaintext(self):
    method n_tokens (line 215) | def n_tokens(self):
  class Sentence (line 219) | class Sentence:
    method __init__ (line 220) | def __init__(self, entry, sentence_start, sentence_ix):
    method to_json (line 266) | def to_json(self):
    method __repr__ (line 284) | def __repr__(self):
    method __len__ (line 295) | def __len__(self):
  class Span (line 299) | class Span:
    method __init__ (line 300) | def __init__(self, start, end, sentence, sentence_offsets=False):
    method start_doc (line 310) | def start_doc(self):
    method end_doc (line 314) | def end_doc(self):
    method span_doc (line 318) | def span_doc(self):
    method span_sent (line 322) | def span_sent(self):
    method text (line 326) | def text(self):
    method __repr__ (line 329) | def __repr__(self):
    method __eq__ (line 332) | def __eq__(self, other):
    method __hash__ (line 339) | def __hash__(self):
  class Token (line 344) | class Token:
    method __init__ (line 345) | def __init__(self, ix, sentence, sentence_offsets=False):
    method ix_doc (line 350) | def ix_doc(self):
    method text (line 354) | def text(self):
    method __repr__ (line 357) | def __repr__(self):
  class NER (line 361) | class NER:
    method __init__ (line 362) | def __init__(self, ner, sentence, sentence_offsets=False):
    method __repr__ (line 366) | def __repr__(self):
    method __eq__ (line 369) | def __eq__(self, other):
    method to_json (line 372) | def to_json(self):
  class PredictedNER (line 376) | class PredictedNER(NER):
    method __init__ (line 377) | def __init__(self, ner, sentence, sentence_offsets=False):
    method __repr__ (line 383) | def __repr__(self):
    method to_json (line 386) | def to_json(self):
  class Relation (line 393) | class Relation:
    method __init__ (line 394) | def __init__(self, relation, sentence, sentence_offsets=False):
    method __repr__ (line 403) | def __repr__(self):
    method __eq__ (line 406) | def __eq__(self, other):
    method to_json (line 409) | def to_json(self):
  class PredictedRelation (line 413) | class PredictedRelation(Relation):
    method __init__ (line 414) | def __init__(self, relation, sentence, sentence_offsets=False):
    method __repr__ (line 420) | def __repr__(self):
    method to_json (line 423) | def to_json(self):

FILE: span_model/data/dataset_readers/span_model.py
  class SpanModelDataException (line 28) | class SpanModelDataException(Exception):
  class SpanModelReader (line 33) | class SpanModelReader(DatasetReader):
    method __init__ (line 39) | def __init__(
    method _read (line 55) | def _read(self, file_path: str):
    method _too_long (line 69) | def _too_long(self, span):
    method _process_ner (line 72) | def _process_ner(self, span_tuples, sent):
    method _process_relations (line 86) | def _process_relations(self, span_tuples, sent):
    method _process_sentence (line 106) | def _process_sentence(self, sent: Sentence, dataset: str):
    method _process_sentence_fields (line 164) | def _process_sentence_fields(self, doc: Document):
    method text_to_instance (line 188) | def text_to_instance(self, doc_text: Dict[str, Any]):
    method _instances_from_cache_file (line 209) | def _instances_from_cache_file(self, cache_filename):
    method _instances_to_cache_file (line 215) | def _instances_to_cache_file(self, cache_filename, instances):
    method _normalize_word (line 220) | def _normalize_word(word):

FILE: span_model/predictors/span_model.py
  class SpanModelPredictor (line 18) | class SpanModelPredictor(Predictor):
    method __init__ (line 27) | def __init__(self, model: Model, dataset_reader: DatasetReader) -> None:
    method predict (line 30) | def predict(self, document):
    method predict_tokenized (line 33) | def predict_tokenized(self, tokenized_document: List[str]) -> JsonDict:
    method dump_line (line 38) | def dump_line(self, outputs):
    method predict_instance (line 44) | def predict_instance(self, instance):

FILE: span_model/training/f1.py
  function safe_div (line 6) | def safe_div(num, denom):
  function compute_f1 (line 13) | def compute_f1(predicted, gold, matched):

FILE: span_model/training/ner_metrics.py
  class NERMetrics (line 14) | class NERMetrics(Metric):
    method __init__ (line 19) | def __init__(self, number_of_classes: int, none_label: int = 0):
    method __call__ (line 25) | def __call__(
    method get_metric (line 51) | def get_metric(self, reset=False):
    method reset (line 72) | def reset(self):

FILE: span_model/training/relation_metrics.py
  class RelationMetrics (line 8) | class RelationMetrics(Metric):
    method __init__ (line 13) | def __init__(self):
    method __call__ (line 20) | def __call__(self, predicted_relation_list, metadata_list):
    method get_metric (line 33) | def get_metric(self, reset=False):
    method reset (line 45) | def reset(self):
  class SpanPairMetrics (line 51) | class SpanPairMetrics(RelationMetrics):
    method __call__ (line 53) | def __call__(self, predicted_relation_list, metadata_list):