hyperbase-parser-ab 0.1.0__py3-none-any.whl

hyperbase_parser_ab/__init__.py

@@ -0,0 +1,3 @@
+from hyperbase_parser_ab.parser import AlphaBetaParser
+
+__all__ = ["AlphaBetaParser"]

hyperbase_parser_ab/alpha.py

@@ -0,0 +1,69 @@
+import numpy as np
+from numpy.typing import NDArray
+from scipy.sparse import spmatrix
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.preprocessing import OneHotEncoder
+from spacy.tokens import Span
+
+from hyperbase_parser_ab.atomizer import Atomizer
+
+
+class Alpha(object):
+    def __init__(self, cases_str: str | None = None, use_atomizer: bool = False) -> None:
+        if use_atomizer:
+            self.atomizer: Atomizer | None = Atomizer()
+        elif cases_str:
+            self.atomizer = None
+
+            X: list[tuple[str, str, str, str, str]] = []
+            y: list[list[str]] = []
+
+            for line in cases_str.strip().split('\n'):
+                sline: str = line.strip()
+                if len(sline) > 0:
+                    row: list[str] = sline.strip().split('\t')
+                    true_value: str = row[0]
+                    tag: str = row[3]
+                    dep: str = row[4]
+                    hpos: str = row[6]
+                    hdep: str = row[8]
+                    pos_after: str = row[19]
+
+                    y.append([true_value])
+                    X.append((tag, dep, hpos, hdep, pos_after))
+
+            if len(y) > 0:
+                self.empty: bool = False
+
+                self.encX: OneHotEncoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
+                self.encX.fit(np.array(X))
+                self.ency: OneHotEncoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
+                self.ency.fit(np.array(y))
+
+                X_: NDArray | spmatrix = self.encX.transform(np.array(X))
+                y_: NDArray | spmatrix = self.ency.transform(np.array(y))
+
+                self.clf: RandomForestClassifier = RandomForestClassifier(random_state=777)
+                self.clf.fit(X_, y_)
+        else:
+            self.empty = True
+
+    def predict(self, sentence: Span, features: list[tuple[str, str, str, str, str]]) -> tuple[str, ...] | list[str]:
+        if self.atomizer:
+            preds: list[tuple[str, str]] = self.atomizer.atomize(
+                sentence=str(sentence),
+                tokens=[str(token) for token in sentence])
+            atom_types: list[str] = [pred[1] for pred in preds]
+
+            # force known cases
+            for i in range(len(atom_types)):
+                if sentence[i].pos_ == 'VERB':
+                    atom_types[i] = 'P'
+            return atom_types
+        else:
+            # an empty classifier always predicts 'C'
+            if self.empty:
+                return tuple('C' for _ in range(len(features)))
+            _features: NDArray | spmatrix = self.encX.transform(np.array(features))
+            preds_arr: NDArray | spmatrix = self.ency.inverse_transform(self.clf.predict(_features))
+            return tuple(pred[0] if pred else 'C' for pred in preds_arr)

hyperbase_parser_ab/atomizer.py

@@ -0,0 +1,142 @@
+from collections import Counter
+
+import torch
+from transformers import AutoTokenizer, AutoModelForTokenClassification, PreTrainedTokenizerBase, PreTrainedModel
+
+
+HF_REPO: str = "hyperquest/atom-classifier"
+
+
+class Atomizer:
+    def __init__(self, model_path: str | None = None) -> None:
+        model_id: str = model_path or HF_REPO
+        self.model_path: str = model_id
+        self.tokenizer: PreTrainedTokenizerBase = AutoTokenizer.from_pretrained(model_id, use_fast=True)
+        self.model: PreTrainedModel = AutoModelForTokenClassification.from_pretrained(model_id)
+        assert self.model.config.id2label
+        self.id2label: dict[int, str] = self.model.config.id2label
+
+    def atomize(self,
+                sentence: str,
+                tokens: list[str] | None = None
+               ) -> list[tuple[str, str]]:
+        # Tokenize the raw sentence and request offsets
+        encoded = self.tokenizer(
+            sentence,
+            return_tensors="pt",
+            truncation=True,
+            return_offsets_mapping=True
+        )
+
+        offset_mapping = encoded.pop("offset_mapping")  # remove so model doesn't see it
+        word_ids: list[int | None] = encoded.word_ids(0)
+
+        with torch.no_grad():
+            outputs = self.model(**encoded)
+
+        pred_ids: list[int] = outputs.logits.argmax(-1)[0].tolist()
+        offset_mapping = offset_mapping[0].tolist()
+
+        if tokens is not None:
+            # Map provided tokens to model predictions based on character offsets
+            return self._map_tokens_to_predictions(sentence, tokens, word_ids, pred_ids, offset_mapping)
+
+        predicted_labels: list[tuple[str, str]] = []
+        current_word_id: int | None = None
+        current_start: int | None = None
+        current_end: int = -1
+        current_label: str | None = None
+
+        for idx, word_id in enumerate(word_ids):
+            if word_id is None:
+                continue  # skip CLS, SEP, etc.
+
+            start: int
+            end: int
+            start, end = offset_mapping[idx]
+            label_id: int = pred_ids[idx]
+            label: str = self.id2label[label_id]
+
+            if word_id != current_word_id:
+                # flush previous word
+                if current_label is not None:
+                    word_text: str = sentence[current_start:current_end]
+                    predicted_labels.append((word_text, current_label))
+
+                # start new word
+                current_word_id = word_id
+                current_start = start
+                current_end = end
+                current_label = label
+            else:
+                # same word, extend its span
+                current_end = max(current_end, end)
+
+        # flush last word
+        if current_label is not None:
+            word_text = sentence[current_start:current_end]
+            predicted_labels.append((word_text, current_label))
+
+        return predicted_labels
+
+    def _map_tokens_to_predictions(self,
+                                   sentence: str,
+                                   tokens: list[str],
+                                   word_ids: list[int | None],
+                                   pred_ids: list[int],
+                                   offset_mapping: list[list[int]]
+                                  ) -> list[tuple[str, str]]:
+        """
+        Maps provided tokens to model predictions by finding character offsets
+        and assigning the most appropriate label based on overlapping model tokens.
+        """
+        # Find character positions of each provided token in the sentence
+        token_positions: list[tuple[int, int] | None] = []
+        search_start: int = 0
+
+        for token in tokens:
+            pos: int = sentence.find(token, search_start)
+            if pos == -1:
+                # Token not found - skip or use fallback
+                token_positions.append(None)
+            else:
+                token_positions.append((pos, pos + len(token)))
+                search_start = pos + len(token)
+
+        # For each provided token, collect overlapping model predictions
+        result: list[tuple[str, str]] = []
+        for token, positions in zip(tokens, token_positions):
+            if positions is None:
+                # Token not found in sentence - assign default label
+                result.append((token, 'C'))
+                continue
+
+            token_start: int
+            token_end: int
+            token_start, token_end = positions
+
+            # Collect all labels from model tokens that overlap with this token
+            overlapping_labels: list[str] = []
+            for idx, word_id in enumerate(word_ids):
+                if word_id is None:
+                    continue
+
+                model_start: int
+                model_end: int
+                model_start, model_end = offset_mapping[idx]
+
+                # Check if model token overlaps with provided token
+                if model_start < token_end and model_end > token_start:
+                    label: str = self.id2label[pred_ids[idx]]
+                    overlapping_labels.append(label)
+
+            # Assign the most common label, or first label if tie
+            if overlapping_labels:
+                # Use most common label
+                most_common_label: str = Counter(overlapping_labels).most_common(1)[0][0]
+                result.append((token, most_common_label))
+            else:
+                # No overlap found - use default
+                result.append((token, 'C'))
+
+        return result

hyperbase_parser_ab/lang_models.py

@@ -0,0 +1,50 @@
+def get_spacy_models(lang: str) -> list[str]:
+    if lang == 'de':
+        return [
+            'de_dep_news_trf',
+            'de_core_news_lg',
+            'de_core_news_md',
+            'de_core_news_sm'
+        ]
+    elif lang == 'en':
+        return [
+            'en_core_web_trf',
+            'en_core_web_lg',
+            'en_core_web_md',
+            'en_core_web_sm'
+        ]
+    elif lang == 'es':
+        return [
+            'es_dep_news_trf',
+            'es_core_news_lg',
+            'es_core_news_md',
+            'es_core_news_sm'
+        ]
+    elif lang == 'fr':
+        return [
+            'fr_dep_news_trf',
+            'fr_core_news_lg',
+            'fr_core_news_md',
+            'fr_core_news_sm'
+        ]
+    elif lang == 'it':
+        return [
+            'it_core_news_lg',
+            'it_core_news_md',
+            'it_core_news_sm'
+        ]
+    elif lang == 'pt':
+        return [
+            'pt_core_news_lg',
+            'pt_core_news_md',
+            'pt_core_news_sm'
+        ]
+    elif lang == 'zh':
+        return [
+            'zh_core_news_trf',
+            'zh_core_news_lg',
+            'zh_core_news_md',
+            'zh_core_news_sm'
+        ]
+    else:
+        return []

hyperbase_parser_ab/parser.py

@@ -0,0 +1,835 @@
+import re
+import traceback
+from typing import Any, cast
+
+import spacy
+from spacy.language import Language
+from spacy.tokens import Doc, Span, Token
+
+import hyperbase.constants as const
+from hyperbase.hyperedge import Atom, Hyperedge, build_atom, hedge, non_unique, unique, UniqueAtom
+from hyperbase.parsers import Parser
+
+from hyperbase_parser_ab.alpha import Alpha
+from hyperbase_parser_ab.lang_models import get_spacy_models
+from hyperbase_parser_ab.rules import apply_rule, Rule, strict_rules, repair_rules
+
+
+def _edge2txt_parts(edge: Hyperedge, parse: dict[str, Any]) -> list[tuple[str, str, int]]:
+    atoms: list[Atom] = [UniqueAtom(atom) for atom in edge.all_atoms()]
+    tokens: list[Token] = [parse['atom2token'][atom] for atom in atoms if atom in parse['atom2token']]
+    txts: list[str] = [token.text for token in tokens]
+    pos: list[int] = [token.i for token in tokens]
+    return list(zip(txts, txts, pos))
+
+
+def _edge2text(edge: Hyperedge, parse: dict[str, Any]) -> str:
+    if edge.not_atom and str(edge[0]) == const.possessive_builder:
+        return _poss2text(edge, parse)
+
+    parts: list[tuple[str, str, int]] = _edge2txt_parts(edge, parse)
+    parts = sorted(parts, key=lambda x: x[2])
+
+    prev_txt: str | None = None
+    txt_parts: list[str] = []
+    sentence: str = str(parse['spacy_sentence'])
+    for txt, _txt, _ in parts:
+        if prev_txt is not None:
+            res: re.Match[str] | None = re.search(r'{}(.*?){}'.format(re.escape(prev_txt), re.escape(txt)), sentence)
+            if res:
+                sep: str = res.group(1)
+            else:
+                sep = ' '
+            if any(letter.isalnum() for letter in sep):
+                sep = ' '
+            txt_parts.append(sep)
+        txt_parts.append(_txt)
+        prev_txt = txt
+    return ''.join(txt_parts)
+
+
+def _concept_type_and_subtype(token: Token) -> str:
+    pos: str = token.pos_
+    dep: str = token.dep_
+    if dep == 'nmod':
+        return 'Cm'
+    if pos == 'ADJ':
+        return 'Ca'
+    elif pos == 'NOUN':
+        return 'Cc'
+    elif pos == 'PROPN':
+        return 'Cp'
+    elif pos == 'NUM':
+        return 'C#'
+    elif pos == 'DET':
+        return 'Cd'
+    elif pos == 'PRON':
+        return 'Ci'
+    else:
+        return 'C'
+
+
+def _modifier_type_and_subtype(token: Token) -> str:
+    pos: str = token.pos_
+    dep: str = token.dep_
+    if dep in {'neg', 'nk'}:
+        return 'Mn'
+    elif dep in {'poss', 'pg', 'ag'}:
+        return 'Mp'
+    elif dep == 'prep':
+        return 'Mt'  # preposition
+    elif dep == 'preconj':
+        return 'Mj'  # conjunctional
+    elif pos == 'ADJ':
+        return 'Ma'
+    elif pos == 'DET':
+        return 'Md'
+    elif pos == 'NUM':
+        return 'M#'
+    elif pos == 'AUX':
+        return 'Mm'  # modal
+    elif token.dep_ == 'prt':
+        return 'Ml'  # particle
+    elif pos == 'PART':
+        return 'Mi'  # infinitive
+    elif pos == 'ADV':  # adverb
+        return 'M'  # quintissential modifier, no subtype needed
+    else:
+        return 'M'
+
+
+def _builder_type_and_subtype(token: Token) -> str:
+    pos: str = token.pos_
+    dep: str = token.dep_
+    if dep in {'case', 'pg', 'ag'}:
+        # if token.head.dep_ == 'poss':
+        return 'Bp'
+    elif pos == 'ADP':
+        return 'Br'  # relational (proposition)
+    elif pos == 'DET':
+        return 'Bd'
+    else:
+        return 'B'
+
+
+def _predicate_type_and_subtype(token: Token) -> str:
+    dep: str = token.dep_
+    if dep in {'advcl', 'csubj', 'csubjpass', 'parataxis'}:
+        return 'Pd'
+    elif dep in {'relcl', 'ccomp', 'acl', 'pcomp', 'xcomp', 'rc'}:
+        return 'P'
+    elif _is_verb(token):
+        return 'Pd'
+    else:
+        return 'P'
+
+
+def _predicate_post_type_and_subtype(edge: Hyperedge, subparts: list[str], args_string: str) -> str:
+    return subparts[0]
+
+
+def _is_verb(token: Token) -> bool:
+    return token.pos_ == 'VERB'
+
+
+def _poss2text(edge: Hyperedge, parse: dict[str, Any]) -> str:
+    part1: str = _edge2text(edge[1], parse).strip()
+    part2: str = _edge2text(edge[2], parse)
+    if part1[-1] == 's':
+        poss: str = "'"
+    else:
+        poss = "'s"
+    return f'{part1}{poss} {part2}'
+
+
+def _generate_tok_pos(atom2word: dict[Atom, tuple[str, int]], edge: Hyperedge) -> str:
+    if edge.atom:
+        uatom: Atom | None = cast(Atom, unique(edge))
+        if uatom is not None and uatom in atom2word:
+            return str(atom2word[uatom][1])
+        else:
+            return '-1'
+    else:
+        return '({})'.format(' '.join([_generate_tok_pos(atom2word, subedge) for subedge in edge]))
+
+
+class AlphaBetaParser(Parser):
+    def __init__(self, lang: str, beta: str = 'repair', normalize: bool = True,
+                 post_process: bool = True, debug: bool = False) -> None:
+        super().__init__()
+
+        self.lang: str = lang
+
+        models: list[str] = get_spacy_models(lang)
+
+        if len(models) == 0:
+            raise RuntimeError(f"Language code '{lang}' is not recognized / language is nor supported.")
+
+        self.nlp: Language | None = None
+        for model in models:
+            if spacy.util.is_package(model):
+                self.nlp = spacy.load(model)
+                print('Using language model: {}'.format(model))
+                break
+        if self.nlp is None:
+            models_list: str = ", ".join(models)
+            raise RuntimeError(f"Language '{lang}' requires one of the following language models to be installed:\n"
+                               f"{models_list}.")
+
+        self.alpha: Alpha = Alpha(use_atomizer=True)
+
+        if beta == 'strict':
+            self.rules: list[Rule] = strict_rules
+        elif beta == 'repair':
+            self.rules = repair_rules
+        else:
+            raise RuntimeError('unkown beta stage: {}'.format(beta))
+        self.normalize: bool = normalize
+        self.post_process: bool = post_process
+        self.debug: bool = debug
+
+        self.atom2token: dict[Atom, Token] = {}
+        self.temp_atoms: set[Atom] = set()
+        self.orig_atom: dict[Atom, UniqueAtom] = {}
+        self.token2atom: dict[Token, Atom] = {}
+        self.depths: dict[Atom, int] = {}
+        self.connections: set[tuple[Atom, Atom]] = set()
+        self.edge2text: dict[Hyperedge, str] = {}
+        self.edge2toks: dict[Hyperedge, tuple[Token, ...]] = {}
+        self.toks2edge: dict[tuple[Token, ...], Hyperedge] = {}
+        self.cur_text: str | None = None
+        self.doc: Doc | None = None
+        self.beta: str = beta
+
+    def debug_msg(self, msg: str) -> None:
+        if self.debug:
+            print(msg)
+
+    def parse_sentence(self, sentence: str) -> list[dict[str, object]]:
+        # This runs spacy own sentensizer anyway...
+
+        sentence = re.sub(r'\s+', ' ', sentence).strip()
+
+        if self.nlp:
+            self.reset(sentence)
+            parses: list[dict[str, object]] = []
+            try:
+                self.doc = self.nlp(sentence)
+                offset: int = 0
+                for sent in self.doc.sents:
+                    parse: dict[str, object] | None = self.parse_spacy_sentence(sent, offset=offset)
+                    if parse:
+                        parses.append(parse)
+                    offset += len(sent)
+            except RuntimeError as error:
+                print(error)
+            return parses
+        else:
+            raise RuntimeError("spaCy model failed to initialize.")
+
+    def parse_spacy_sentence(self, sent: Span, atom_sequence: list[Atom] | None = None,
+                             offset: int = 0) -> dict[str, object] | None:
+        try:
+            if atom_sequence is None:
+                atom_sequence = self._build_atom_sequence(sent)
+
+            self._compute_depths_and_connections(sent.root)
+
+            edge: Hyperedge | None = None
+            result: list[Hyperedge] | None
+            failed: bool
+            result, failed = self._parse_atom_sequence(atom_sequence)
+            if result and len(result) == 1:
+                edge = non_unique(result[0])
+
+            atom2word: dict[Atom, tuple[str, int]] = {}
+            if edge:
+                edge = self._apply_arg_roles(edge)
+                if self.beta == 'repair':
+                    edge = self._repair(edge)
+                if self.normalize:
+                    edge = self._normalize(edge)
+                if self.post_process:
+                    edge = self._post_process(edge)
+                if edge is not None:
+                    atom2word = self._generate_atom2word(edge, offset=offset)
+
+            if edge is None:
+                return None
+
+            return {
+                'edge': edge,
+                'failed': failed,
+                'text': str(sent).strip(),
+                'tokens': [str(token) for token in sent],
+                'tok_pos': _generate_tok_pos(atom2word, edge)
+            }
+        except Exception as e:
+            print('Caught exception: {} while parsing: "{}"'.format(str(e), str(sent)))
+            traceback.print_exc()
+            return None
+
+    def manual_atom_sequence(self, sentence: Span, token2atom: dict[Token, Atom]) -> list[Atom]:
+        self.token2atom = {}
+
+        atomseq: list[Atom] = []
+        for token in sentence:
+            if token in token2atom:
+                atom: Atom | None = token2atom[token]
+            else:
+                atom = None
+            if atom:
+                uatom: Atom = UniqueAtom(atom)
+                self.dep_[uatom] = token
+                self.token2atom[token] = uatom
+                self.orig_atom[uatom] = uatom
+                atomseq.append(uatom)
+        return atomseq
+
+    def reset(self, text: str) -> None:
+        self.dep_: dict[Atom, Token] = {}
+        self.temp_atoms = set()
+        self.orig_atom = {}
+        self.edge2toks = {}
+        self.toks2edge = {}
+        self.edge2coref: dict[Hyperedge, object] = {}
+        self.resolved_corefs: set[object] = set()
+        self.cur_text = text
+
+    def _builder_arg_roles(self, edge: Hyperedge) -> str:
+        depth1: int = self._dep_depth(edge[1])
+        depth2: int = self._dep_depth(edge[2])
+        if depth1 < depth2:
+            return 'ma'
+        elif depth1 > depth2:
+            return 'am'
+        else:
+            return 'mm'
+
+
+    def _relation_arg_role(self, edge: Hyperedge) -> str:
+        head_token: Token | None = self._head_token(edge)
+        if not head_token:
+            return '?'
+        dep: str = head_token.dep_
+
+        # subject
+        if dep in {'nsubj', 'sb'}:
+            return 's'
+        # passive subject
+        elif dep in {'nsubjpass', 'nsubj:pass'}:
+            return 'p'
+        # agent
+        elif dep == 'agent':
+            return 'a'
+        # object
+        elif dep in {'obj', 'dobj', 'pobj', 'prt', 'oprd', 'acomp', 'attr', 'ROOT', 'oa', 'pd'}:
+            return 'o'
+        # indirect object
+        elif dep in {'iobj', 'dative', 'obl:arg', 'da'}:
+            return 'i'
+        # specifier
+        elif dep in {'advcl', 'prep', 'npadvmod', 'advmod', 'mo', 'mnr'}:
+            return 'x'
+        # parataxis
+        elif dep in {'parataxis', 'par'}:
+            return 't'
+        # interjection
+        elif dep in {'intj', 'ng', 'dm'}:
+            return 'j'
+        # clausal complement
+        elif dep in {'xcomp', 'ccomp', 'oc'}:
+            return 'r'
+        else:
+            return '?'
+
+
+    def _adjust_score(self, edges: list[Hyperedge]) -> int:
+        min_depth: int = 9999999
+        appos: bool = False
+        min_appos_depth: int = 9999999
+
+        if all([edge.mtype() == 'C' for edge in edges]):
+            for edge in edges:
+                token: Token | None = self._head_token(edge)
+                if token is None:
+                    continue
+                depth: int = self.depths[self.token2atom[token]]
+                if depth < min_depth:
+                    min_depth = depth
+                if token.dep_ == 'appos':
+                    appos = True
+                    if depth < min_appos_depth:
+                        min_appos_depth = depth
+
+        if appos and min_appos_depth > min_depth:
+            return -99
+        else:
+            return 0
+
+    def _head_token(self, edge: Hyperedge) -> Token | None:
+        atoms: list[Atom] = [
+            cast(Atom, uatom)
+            for atom in edge.all_atoms()
+            if (uatom := unique(atom)) is not None and uatom in self.atom2token
+        ]
+        min_depth: int = 9999999
+        main_atom: Atom | None = None
+        for atom in atoms:
+            if atom in self.orig_atom:
+                oatom: Atom = self.orig_atom[atom]
+                if oatom in self.depths:
+                    depth: int = self.depths[oatom]
+                    if depth < min_depth:
+                        min_depth = depth
+                        main_atom = atom
+        if main_atom:
+            return self.atom2token[main_atom]
+        else:
+            return None
+
+    def _dep_depth(self, edge: Hyperedge) -> int:
+        atoms: list[Atom] = [
+            cast(Atom, uatom)
+            for atom in edge.all_atoms()
+            if (uatom := unique(atom)) is not None and uatom in self.atom2token
+        ]
+        mdepth: int = 99999999
+        for atom in atoms:
+            if atom in self.orig_atom:
+                oatom: Atom = self.orig_atom[atom]
+                if oatom in self.depths:
+                    depth: int = self.depths[oatom]
+                    if depth < mdepth:
+                        mdepth = depth
+        return mdepth
+
+    def _build_atom(self, token: Token, ent_type: str, last_token: Token | None) -> Atom:
+        text: str = token.text.lower()
+        et: str = ent_type
+
+        if ent_type[0] == 'P':
+            atom: Atom = self._build_atom_predicate(token, ent_type, last_token)
+        elif ent_type[0] == 'T':
+            atom = self._build_atom_trigger(token, ent_type)
+        elif ent_type[0] == 'M':
+            atom = self._build_atom_modifier(token)
+        else:
+            atom = build_atom(text, et, self.lang)
+        return atom
+
+    def _build_atom_predicate(self, token: Token, ent_type: str, last_token: Token | None) -> Atom:
+        text: str = token.text.lower()
+        et: str = ent_type
+
+        # first naive assignment of predicate subtype
+        # (can be revised at post-processing stage)
+        if ent_type == 'Pd':
+            # interrogative cases
+            if (last_token and
+                    last_token.tag_ == '.' and
+                    last_token.dep_ == 'punct' and
+                    last_token.lemma_.strip() == '?'):
+                ent_type = 'P?'
+            # declarative (by default)
+            else:
+                ent_type = 'Pd'
+
+        return build_atom(text, ent_type, self.lang)
+
+    def _build_atom_trigger(self, token: Token, ent_type: str) -> Atom:
+        text: str = token.text.lower()
+        et: str = 'Tv' if _is_verb(token) else ent_type
+        return build_atom(text, et, self.lang)
+
+    def _build_atom_modifier(self, token: Token) -> Atom:
+        text: str = token.text.lower()
+        et: str = 'Mv' if _is_verb(token) else _modifier_type_and_subtype(token)
+        return build_atom(text, et, self.lang)
+
+    def _repair(self, edge: Hyperedge) -> Hyperedge:
+        if edge.not_atom:
+            new_edge: Hyperedge | None = hedge([self._repair(subedge) for subedge in edge])
+            if new_edge is None:
+                return edge
+            edge = new_edge
+
+            if len(edge) == 3 and str(edge[0])[:4] == '+/B.':
+                if len(edge[1]) == 2 and edge[1].cmt == 'J':
+                    return cast(Hyperedge, hedge([edge[1][0], edge[1][1], edge[2]]))
+                elif len(edge[2]) == 2 and edge[2].cmt == 'J':
+                    return cast(Hyperedge, hedge([edge[2][0], edge[1], edge[2][1]]))
+
+        return edge
+
+    def _normalize(self, edge: Hyperedge) -> Hyperedge:
+        if edge.not_atom:
+            new_edge: Hyperedge | None = hedge([self._normalize(subedge) for subedge in edge])
+            if new_edge is None:
+                return edge
+            edge = new_edge
+
+            # Move modifier to internal connector if it is applied to
+            # relations, specifiers or conjunctions
+            if edge.cmt == 'M' and not edge[1].atom:
+                innner_conn: str | None = edge[1].cmt
+                if innner_conn in {'P', 'T', 'J'}:
+                    return cast(Hyperedge, hedge(((edge[0], edge[1][0]),) + edge[1][1:]))
+
+        return edge
+
+    def _update_atom(self, old: Atom, new: Atom) -> None:
+        uold: Atom = UniqueAtom(old)
+        unew: Atom = UniqueAtom(new)
+        if uold in self.atom2token:
+            self.atom2token[unew] = self.atom2token[uold]
+            self.temp_atoms.add(uold)
+        self.orig_atom[unew] = uold
+
+    def _replace_atom(self, edge: Hyperedge, old: Atom, new: Atom) -> Hyperedge:
+        self._update_atom(old, new)
+        return edge.replace_atom(old, new)
+
+    def _insert_edge_with_argrole(self, edge: Hyperedge, arg: Hyperedge, argrole: str, pos: int) -> Hyperedge:
+        new_edge: Hyperedge = edge.insert_edge_with_argrole(arg, argrole, pos)
+        old_pred: Atom = edge[0].inner_atom()
+        new_pred: Atom = new_edge[0].inner_atom()
+        self._update_atom(old_pred, new_pred)
+        return new_edge
+
+    def _replace_argroles(self, edge: Hyperedge, argroles: str) -> Hyperedge:
+        new_edge: Hyperedge = edge.replace_argroles(argroles)
+        old_pred: Atom = edge[0].inner_atom()
+        new_pred: Atom = new_edge[0].inner_atom()
+        self._update_atom(old_pred, new_pred)
+        return new_edge
+
+    def _apply_arg_roles(self, edge: Hyperedge) -> Hyperedge:
+        if edge.atom:
+            return edge
+
+        new_entity: Hyperedge = edge
+
+        # Extend predicate connectors with argument types
+        if edge.connector_mtype() == 'P':
+            pred: Atom | None = edge.atom_with_type('P')
+            assert pred is not None
+            subparts: list[str] = pred.parts()[1].split('.')
+            args: list[str] = [self._relation_arg_role(param) for param in edge[1:]]
+            args_string: str = ''.join(args)
+            # TODO: this is done to detect imperative, to refactor
+            pt: str = _predicate_post_type_and_subtype(edge, subparts, args_string)
+            if len(subparts) > 2:
+                new_part: str = '{}.{}.{}'.format(pt, args_string, subparts[2])
+            else:
+                new_part = '{}.{}'.format(pt, args_string)
+            new_pred: Atom = pred.replace_atom_part(1, new_part)
+            unew_pred: Atom = UniqueAtom(new_pred)
+            upred: Atom = UniqueAtom(pred)
+            self.atom2token[unew_pred] = self.atom2token[upred]
+            self.temp_atoms.add(upred)
+            self.orig_atom[unew_pred] = upred
+            new_entity = edge.replace_atom(pred, new_pred, unique=True)
+
+        # Extend builder connectors with argument types
+        elif edge.connector_mtype() == 'B':
+            builder: Atom | None = edge.atom_with_type('B')
+            assert builder is not None
+            subparts = builder.parts()[1].split('.')
+            arg_roles: str = self._builder_arg_roles(edge)
+            if len(arg_roles) > 0:
+                if len(subparts) > 1:
+                    subparts[1] = arg_roles
+                else:
+                    subparts.append(arg_roles)
+                new_part = '.'.join(subparts)
+                new_builder: Atom = builder.replace_atom_part(1, new_part)
+                ubuilder: Atom = UniqueAtom(builder)
+                unew_builder: Atom = UniqueAtom(new_builder)
+                if ubuilder in self.atom2token:
+                    self.atom2token[unew_builder] = self.atom2token[ubuilder]
+                    self.temp_atoms.add(ubuilder)
+                self.orig_atom[unew_builder] = ubuilder
+                new_entity = edge.replace_atom(builder, new_builder, unique=True)
+
+        new_args: list[Hyperedge] = [self._apply_arg_roles(subentity) for subentity in new_entity[1:]]
+        new_entity = cast(Hyperedge, hedge([new_entity[0]] + new_args))
+
+        return new_entity
+
+    def _generate_atom2word(self, edge: Hyperedge, offset: int = 0) -> dict[Atom, tuple[str, int]]:
+        atom2word: dict[Atom, tuple[str, int]] = {}
+        atoms: list[Atom] = edge.all_atoms()
+        for atom in atoms:
+            uatom: Atom = UniqueAtom(atom)
+            if uatom in self.atom2token:
+                token: Token = self.atom2token[uatom]
+                word: tuple[str, int] = (token.text, token.i - offset)
+                atom2word[uatom] = word
+        return atom2word
+
+    def _parse_token(self, token: Token, atom_type: str) -> Atom | None:
+        if atom_type == 'X':
+            return None
+        elif atom_type == 'C':
+            atom_type = _concept_type_and_subtype(token)
+        elif atom_type == 'M':
+            atom_type = _modifier_type_and_subtype(token)
+        elif atom_type == 'B':
+            atom_type = _builder_type_and_subtype(token)
+        elif atom_type == 'P':
+            atom_type = _predicate_type_and_subtype(token)
+
+        # last token is useful to determine predicate subtype
+        tokens: list[Token] = list(token.lefts) + list(token.rights)
+        last_token: Token | None = tokens[-1] if len(tokens) > 0 else None
+
+        atom: Atom = self._build_atom(token, atom_type, last_token)
+        self.debug_msg('ATOM: {}'.format(atom))
+
+        return atom
+
+    def _build_atom_sequence(self, sentence: Span) -> list[Atom]:
+        features: list[tuple[str, str, str, str, str]] = []
+        for pos, token in enumerate(sentence):
+            head: Token = token.head
+            tag: str = token.tag_
+            dep: str = token.dep_
+            hpos: str = head.pos_ if head else ''
+            hdep: str = head.dep_ if head else ''
+            if pos + 1 < len(sentence):
+                pos_after: str = sentence[pos + 1].pos_
+            else:
+                pos_after = ''
+            features.append((tag, dep, hpos, hdep, pos_after))
+
+        assert self.alpha is not None, "Alpha classifier must be initialized before parsing"
+        atom_types: tuple[str, ...] | list[str] = self.alpha.predict(sentence, features)
+
+        self.token2atom = {}
+
+        atomseq: list[Atom] = []
+        for token, atom_type in zip(sentence, atom_types):
+            atom: Atom | None = self._parse_token(token, atom_type)
+            if atom:
+                uatom: Atom = UniqueAtom(atom)
+                self.atom2token[uatom] = token
+                self.token2atom[token] = uatom
+                self.orig_atom[uatom] = uatom
+                atomseq.append(uatom)
+        return atomseq
+
+    def _compute_depths_and_connections(self, root: Token, depth: int = 0) -> None:
+        if depth == 0:
+            self.depths = {}
+            self.connections = set()
+
+        if root in self.token2atom:
+            parent_atom: Atom | None = self.token2atom[root]
+            self.depths[parent_atom] = depth
+        else:
+            parent_atom = None
+
+        for child in root.children:
+            if parent_atom and child in self.token2atom:
+                child_atom: Atom = self.token2atom[child]
+                self.connections.add((parent_atom, child_atom))
+                self.connections.add((child_atom, parent_atom))
+            self._compute_depths_and_connections(child, depth + 1)
+
+    def _is_pair_connected(self, atoms1: list[Atom], atoms2: list[Atom]) -> bool:
+        for atom1 in atoms1:
+            for atom2 in atoms2:
+                if atom1 in self.orig_atom and atom2 in self.orig_atom:
+                    pair: tuple[Atom, Atom] = (self.orig_atom[atom1], self.orig_atom[atom2])
+                    if pair in self.connections:
+                        return True
+        return False
+
+    def _are_connected(self, atom_sets: list[list[Atom]], connector_pos: int) -> bool:
+        conn: bool = True
+        for pos, arg in enumerate(atom_sets):
+            if pos != connector_pos:
+                if not self._is_pair_connected(atom_sets[connector_pos], arg):
+                    conn = False
+                    break
+        return conn
+
+    def _score(self, edges: list[Hyperedge]) -> int:
+        atom_sets: list[list[Atom]] = [edge.all_atoms() for edge in edges]
+
+        conn: bool = False
+        for pos in range(len(edges)):
+            if self._are_connected(atom_sets, pos):
+                conn = True
+                break
+
+        mdepth: int = 99999999
+        for atom_set in atom_sets:
+            for atom in atom_set:
+                if atom in self.orig_atom:
+                    oatom: Atom = self.orig_atom[atom]
+                    if oatom in self.depths:
+                        depth: int = self.depths[oatom]
+                        if depth < mdepth:
+                            mdepth = depth
+
+        return (10000000 if conn else 0) + (mdepth * 100) + self._adjust_score(edges)
+
+    def _parse_atom_sequence(self, atom_sequence: list[Atom]) -> tuple[list[Hyperedge] | None, bool]:
+        sequence: list[Hyperedge] = list(atom_sequence)
+        while True:
+            action: tuple[Rule, int, Hyperedge, int, int] | None = None
+            best_score: int = -999999999
+            for rule_number, rule in enumerate(self.rules):
+                window_start: int = rule.size - 1
+                for pos in range(window_start, len(sequence)):
+                    new_edge: Hyperedge | None = apply_rule(rule, sequence, pos)
+                    if new_edge:
+                        score: int = self._score(sequence[pos - window_start:pos + 1])
+                        score -= rule_number
+                        if score > best_score:
+                            action = (rule, score, new_edge, window_start, pos)
+                            best_score = score
+
+            # parse failed, make best effort to return something
+            if action is None:
+                # if all else fails...
+                if len(sequence) > 0:
+                    fallback: Hyperedge | None = hedge([':/J/.'] + sequence[:2])
+                    new_sequence: list[Hyperedge] = ([fallback] if fallback else []) + sequence[2:]
+                else:
+                    return None, True
+            else:
+                rule, s, new_edge, window_start, pos = action
+                new_sequence = (sequence[:pos - window_start] + [new_edge] + sequence[pos + 1:])
+
+                self.debug_msg('rule: {}'.format(rule))
+                self.debug_msg('score: {}'.format(score))
+                self.debug_msg('new_edge: {}'.format(new_edge))
+                self.debug_msg('new_sequence: {}'.format(new_sequence))
+
+            sequence = new_sequence
+            if len(sequence) < 2:
+                return sequence, False
+
+    def sentensize(self, text: str) -> list[str]:
+        if self.nlp:
+            doc: Doc = self.nlp(text.strip())
+            return [str(sent).strip() for sent in doc.sents]
+        else:
+            raise RuntimeError("spaCy model failed to initialize.")
+
+    def _edge2toks(self, edge: Hyperedge) -> None:
+        uatoms: list[Hyperedge | None] = [unique(atom) for atom in edge.all_atoms()]
+        toks: tuple[Token, ...] = tuple(sorted(
+            [self.atom2token[uatom] for uatom in uatoms if uatom is not None and uatom in self.atom2token]
+        ))
+        self.edge2toks[edge] = toks
+        self.toks2edge[toks] = edge
+        if edge.not_atom:
+            for subedge in edge:
+                self._edge2toks(subedge)
+
+    # ===============
+    # Post-processing
+    # ===============
+    def _insert_arg_in_tail(self, edge: Hyperedge, arg: Hyperedge) -> Hyperedge:
+        if edge.atom:
+            return edge
+
+        if edge.cmt == 'P':
+            ars: str = edge.argroles()
+            ar: str | None = None
+            if 'p' in ars:
+                if 'a' not in ars:
+                    ar = 'a'
+            elif 'a' in ars:
+                ar = 'p'
+            elif 's' not in ars:
+                ar = 's'
+            elif 'o' not in ars:
+                ar = 'o'
+            if ar:
+                return self._insert_edge_with_argrole(edge, arg, ar, len(edge))
+
+        new_tail: Hyperedge = self._insert_arg_in_tail(edge[-1], arg)
+        if new_tail != edge[-1]:
+            return cast(Hyperedge, hedge(list(edge[:-1]) + [new_tail]))
+        if edge.cmt != 'P':
+            return edge
+        ars = edge.argroles()
+        if ars == '':
+            return edge
+        return self._insert_edge_with_argrole(edge, arg, 'x', len(edge))
+
+    def _insert_spec_rightmost_relation(self, edge: Hyperedge, arg: Hyperedge) -> Hyperedge:
+        if edge.atom:
+            return edge
+        if 'P' in [atom.mt for atom in edge[-1].atoms()]:
+            return cast(Hyperedge, hedge(list(edge[:-1]) + [self._insert_spec_rightmost_relation(edge[-1], arg)]))
+        if edge[0].mt == 'P':
+            return self._insert_edge_with_argrole(edge, arg, 'x', len(edge))
+        for pos, subedge in reversed(list(enumerate(edge))):
+            if 'P' in [atom.mt for atom in subedge.atoms()]:
+                new_edge_list: list[Hyperedge] = list(edge)
+                new_edge_list[pos] = self._insert_spec_rightmost_relation(subedge, arg)
+                return cast(Hyperedge, hedge(new_edge_list))
+        return edge
+
+    def _process_colon_conjunctions(self, edge: Hyperedge) -> Hyperedge:
+        if edge.atom:
+            return edge
+        new_edge: Hyperedge | None = hedge([self._process_colon_conjunctions(subedge) for subedge in edge])
+        if new_edge is None:
+            return edge
+        edge = new_edge
+        if str(edge[0]) == ':/J/.' and any(subedge.mt == 'R' for subedge in edge):
+            if edge[1].mt == 'R':
+                # RR
+                if edge[2].mt == 'S':
+                    # second is specification
+                    return self._insert_edge_with_argrole(edge[1], edge[2], 'x', len(edge[1]))
+                # RC
+                elif edge[2].mt == 'C':
+                    return self._insert_arg_in_tail(edge[1], edge[2])
+            # CR
+            elif edge[1].mt == 'C':
+                if edge[2].mt == 'R':
+                    if 's' not in edge[2].argroles():
+                        # concept is subject
+                        return self._insert_edge_with_argrole(edge[2], edge[1], 's', 0)
+            # SR
+            elif edge[1].mt == 'S':
+                if edge[2].mt == 'R':
+                    # first is specification
+                    return self._insert_edge_with_argrole(edge[2], edge[1], 'x', len(edge[2]))
+        return edge
+
+    def _fix_argroles(self, edge: Hyperedge) -> Hyperedge:
+        if edge.atom:
+            return edge
+        new_edge: Hyperedge | None = hedge([self._fix_argroles(subedge) for subedge in edge])
+        if new_edge is None:
+            return edge
+        edge = new_edge
+        ars: str = edge.argroles()
+        if ars != '' and edge.mt == 'R':
+            _ars: str = ''
+            for ar, subedge in zip(ars, edge[1:]):
+                _ar: str = ar
+                if ar == '?':
+                    if subedge.mt == 'R':
+                        _ar = 'r'
+                    elif subedge.mt == 'S':
+                        _ar = 'x'
+                _ars += _ar
+            return self._replace_argroles(edge, _ars)
+        return edge
+
+    def _post_process(self, edge: Hyperedge | None) -> Hyperedge | None:
+        if edge is None:
+            return None
+        _edge: Hyperedge = self._fix_argroles(edge)
+        _edge = self._process_colon_conjunctions(_edge)
+        return _edge

hyperbase_parser_ab/rules.py

@@ -0,0 +1,67 @@
+from hyperbase.hyperedge import Hyperedge, hedge
+
+
+class Rule:
+    def __init__(self, first_type: str, arg_types: set[str], size: int, connector: str | None = None) -> None:
+        self.first_type: str = first_type
+        self.arg_types: set[str] = arg_types
+        self.size: int = size
+        self.connector: str | None = connector
+        self._branches: int = 0
+
+
+strict_rules: list[Rule] = [
+    Rule('C', {'C'}, 2, '+/B/.'),
+    Rule('M', {'C', 'R', 'M', 'S', 'T', 'P', 'B', 'J'}, 2),
+    Rule('B', {'C'}, 3),
+    Rule('T', {'C', 'R'}, 2),
+    Rule('P', {'C', 'R', 'S'}, 6),
+    Rule('P', {'C', 'R', 'S'}, 5),
+    Rule('P', {'C', 'R', 'S'}, 4),
+    Rule('P', {'C', 'R', 'S'}, 3),
+    Rule('P', {'C', 'R', 'S'}, 2),
+    Rule('J', {'C', 'R', 'M', 'S', 'T', 'P', 'B', 'J'}, 3)]
+
+
+repair_rules: list[Rule] = [
+    Rule('C', {'C'}, 2, '+/B/.'),
+    Rule('M', {'C', 'R', 'M', 'S', 'T', 'P', 'B', 'J'}, 2),
+    Rule('B', {'C', 'R'}, 3),
+    Rule('T', {'C', 'R'}, 2),
+    Rule('P', {'C', 'R', 'S'}, 6),
+    Rule('P', {'C', 'R', 'S'}, 5),
+    Rule('P', {'C', 'R', 'S'}, 4),
+    Rule('P', {'C', 'R', 'S'}, 3),
+    Rule('P', {'C', 'R', 'S'}, 2),
+    Rule('J', {'C', 'R', 'M', 'S', 'T', 'P', 'B', 'J'}, 3),
+    Rule('J', {'C', 'R', 'M', 'S', 'T', 'P', 'B', 'J'}, 2)]
+
+
+def apply_rule(rule: Rule, sentence: list[Hyperedge], pos: int) -> Hyperedge | None:
+    for pivot_pos in range(rule.size):
+        args: list[Hyperedge] = []
+        pivot: Hyperedge | None = None
+        valid: bool = True
+        for i in range(rule.size):
+            edge: Hyperedge = sentence[pos - rule.size + i + 1]
+            if i == pivot_pos:
+                if edge.mtype() == rule.first_type:
+                    if rule.connector:
+                        args.append(edge)
+                    else:
+                        pivot = edge
+                else:
+                    valid = False
+                    break
+            else:
+                if edge.mtype() in rule.arg_types:
+                    args.append(edge)
+                else:
+                    valid = False
+                    break
+        if valid:
+            if rule.connector:
+                return hedge([rule.connector] + args)
+            else:
+                return hedge([pivot] + args)
+    return None

hyperbase_parser_ab/sentensizer.py

@@ -0,0 +1,9 @@
+from wtpsplit import SaT
+
+
+class Sentensizer:
+    def __init__(self) -> None:
+        self.sat: SaT = SaT('sat-3l')
+
+    def sentensize(self, text: str) -> list[str]:
+        return list(self.sat.split(text))

hyperbase_parser_ab-0.1.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: hyperbase-parser-ab
+Version: 0.1.0
+Summary: Semantic Hypergraph AlphaBeta Parser
+Project-URL: Homepage, https://hyperquest.ai/hyperbase
+Author-email: "Telmo Menezes et al." <telmo@telmomenezes.net>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: AI,Knowledge Representation,NLP,Natural Language Understanding,Parsing,Semantic Hypergraphs
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Requires-Dist: hyperbase>=0.8.0
+Requires-Dist: pip
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: spacy>=3.8.0
+Requires-Dist: torch>=2.0.0
+Requires-Dist: transformers>=4.46.0
+Provides-Extra: dev
+Requires-Dist: coverage>=7.4.3; extra == 'dev'
+Requires-Dist: datasets>=4.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.6.2; extra == 'dev'
+Requires-Dist: pytest>=9.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.2.2; extra == 'dev'
+Requires-Dist: types-passlib>=1.7.7.20240106; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Hyperbase Alpha-Beta Parser
+
+## A semantic hypergraph parser for natural language
+
+The Alpha-Beta parser is a [Hyperbase](https://hyperquest.ai/hyperbase) plugin that converts natural language text into *Semantic Hypergraphs (SH)*. It works in two stages:
+
+- **Alpha stage**: A multilingual neural token classifier (based on DistilBERT) assigns one of 39 semantic atom types to each token in a sentence -- for example, concepts, predicates, modifiers, builders, triggers and conjunctions.
+- **Beta stage**: A rule-based engine combines classified atoms into ordered, recursive hyperedges using syntactic and semantic composition rules, producing structured representations that can be manipulated with Hyperbase.
+
+## Supported languages
+
+The parser supports any language with a [spaCy](https://spacy.io) model available, including English, French, German, Italian, Portuguese and Spanish.
+
+While the parser is theoretically language-agnostic and could in principle support languages such as Mandarin, which differ substantially in morphological and syntactic structure, the authors' linguistic competence is limited to Germanic and Romance languages. We welcome the help of native speakers or domain experts in validating/improving support for other language families.
+
+## Installation and manual
+
+Installation instructions, the manual and more information can be found here: <https://hyperquest.ai/hyperbase>
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first
+to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

hyperbase_parser_ab-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+hyperbase_parser_ab/__init__.py,sha256=Cf3ZbUHvRSSfXOGAkfY6OMqy7QwZtKiQi-rdGqrPRv4,86
+hyperbase_parser_ab/alpha.py,sha256=4zfa31GI-OeTKzvKnibu3lsU9NEzQm-BB41muRa2bt4,2831
+hyperbase_parser_ab/atomizer.py,sha256=ewHhTWRZGP7ouheFLp-CnOFItnNLu4v3kwPOGgeyPo0,5527
+hyperbase_parser_ab/lang_models.py,sha256=qTAcdZeM_NXTnl5RYzdDq4SH4dZ_oj2mFBUI7fE8PUI,1219
+hyperbase_parser_ab/parser.py,sha256=g5-zxUZKYbOQE0bhojTHsQ9g78MuzCV1rr-4q_WqjFA,31528
+hyperbase_parser_ab/rules.py,sha256=tr8UGTN_BlinjhtmAjm9Gevv-RVGENPFJbnIn9TKqPU,2271
+hyperbase_parser_ab/sentensizer.py,sha256=tO4Qf5X8JmthiYDX_ObBXdvGqzgXC3eGsKieqOEmk2k,209
+hyperbase_parser_ab-0.1.0.dist-info/METADATA,sha256=dLJ0Icaj0b9cIkbzzMP1jHzUuxfqstlt0RSMVx_j6LU,2990
+hyperbase_parser_ab-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+hyperbase_parser_ab-0.1.0.dist-info/entry_points.txt,sha256=rqN89onaLcCtRnbJPFoXC1RCFxRBj2wGo321TDSnqKU,68
+hyperbase_parser_ab-0.1.0.dist-info/licenses/LICENSE,sha256=6p_7YBrzvSBO3phQeZm2sRg0JmEKiyBJwzZVwseDaGE,1118
+hyperbase_parser_ab-0.1.0.dist-info/RECORD,,

hyperbase_parser_ab-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hyperbase_parser_ab-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[hyperbase.parsers]
+alphabeta = hyperbase_parser_ab:AlphaBetaParser

hyperbase_parser_ab-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (C) 2026 CNRS - Centre national de la recherche scientifique
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.