hyperbase 0.8.0__py3-none-any.whl

hyperbase/patterns/common.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from hyperbase import hedge
+from hyperbase.hyperedge import Hyperedge
+from hyperbase.patterns.argroles import edge2rolemap, rolemap_pairings, rolemap2edge
+from hyperbase.patterns.utils import more_general, is_valid
+from hyperbase.patterns.variables import all_variables, is_variable, contains_variable
+
+
+def common_pattern_argroles(edge1: Hyperedge, edge2: Hyperedge) -> Hyperedge | None:
+    rm1 = edge2rolemap(edge1)
+    rm2 = edge2rolemap(edge2)
+
+    _vars = all_variables(edge1) | all_variables(edge2)
+    best_pattern: Hyperedge | None = None
+    for rm1_, rm2_ in rolemap_pairings(rm1, rm2):
+        edge1_ = rolemap2edge(edge1[0], rm1_)
+        edge2_ = rolemap2edge(edge2[0], rm2_)
+
+        subedges = [_common_pattern(se1, se2) for se1, se2 in zip(edge1_, edge2_)]
+        if any(subedge is None for subedge in subedges):
+            continue
+        argroles = edge1_[0].argroles()
+        if argroles == '':
+            # deal with (*/P.{} or */B.{})
+            pattern = hedge('*/{}'.format(edge1_.mtype()))
+        else:
+            pattern = hedge(subedges)
+            if pattern is None:
+                continue
+            pattern = pattern.replace_argroles('{{{}}}'.format(edge1_[0].argroles()))
+
+        if pattern is not None and _vars == all_variables(pattern):
+            if best_pattern is None or more_general(best_pattern, pattern):
+                best_pattern = pattern
+
+    if best_pattern is None:
+        return None
+
+    return best_pattern.normalized()
+
+
+def common_type(edges: Sequence[Hyperedge]) -> str | None:
+    types = [edge.type() for edge in edges]
+    if len(set(types)) == 1:
+        return types[0]
+    types = [edge.mtype() for edge in edges]
+    if len(set(types)) == 1:
+        return types[0]
+    return None
+
+
+def common_pattern_atoms(atoms: Sequence[Hyperedge]) -> Hyperedge | None:
+    roots = [atom.root() for atom in atoms]  # type: ignore[attr-defined]
+
+    if len(set(roots)) != 1 or '*' in roots:
+        root = '*'
+    else:
+        root = roots[0]
+
+    if any(len(str(atom).split('/')) == 1 for atom in atoms):
+        atype: str | None = None
+    else:
+        atype = common_type(atoms)
+
+    roles1: list[str | None] = []
+    roles2: list[str | None] = []
+    for atom in atoms:
+        role = atom.role()  # type: ignore[attr-defined]
+        r1: str | None = role[1] if len(role) > 1 else None
+        r2: str | None = role[2] if len(role) > 2 else None
+        roles1.append(r1)
+        roles2.append(r2)
+
+    final_role1: str | None = None
+    final_role2: str | None = None
+    if len(set(roles1)) == 1 and roles1[0] is not None:
+        final_role1 = roles1[0]
+        if len(set(roles2)) == 1 and roles2[0] is not None:
+            final_role2 = roles2[0]
+
+    if atype is None:
+        atom_str = root
+    else:
+        role_parts = [atype]
+        if final_role1 is not None:
+            role_parts.append(final_role1)
+            if final_role2 is not None:
+                role_parts.append(final_role2)
+        role_str = '.'.join(role_parts)
+        atom_str = '{}/{}'.format(root, role_str)
+
+    return hedge(atom_str)
+
+
+def _common_pattern(edge1: Hyperedge, edge2: Hyperedge) -> Hyperedge | None:
+    nedge1 = edge1
+    nedge2 = edge2
+
+    # variables
+    if is_variable(nedge1):
+        var1 = nedge1[2]
+    else:
+        var1 = None
+    if is_variable(nedge2):
+        var2 = nedge2[2]
+        if var1 is None:
+            return None
+    else:
+        var2 = None
+        if var1:
+            return None
+    if var1 or var2:
+        # different variables on same position?
+        if var1 and var2 and var1 != var2:
+            return None
+        var = None
+        if var1:
+            vedge1 = nedge1[1]
+            var = var1
+        else:
+            vedge1 = nedge1
+        if var2:
+            vedge2 = nedge2[1]
+            var = var2
+        else:
+            vedge2 = nedge2
+        vedge = _common_pattern(vedge1, vedge2)
+        if vedge is None or contains_variable(vedge):
+            return None
+        else:
+            return hedge(('var', vedge, var))
+
+    # both are atoms
+    if nedge1.atom and nedge2.atom:
+        return common_pattern_atoms((nedge1, nedge2))
+    # at least one non-atom
+    else:
+        if nedge1.not_atom and nedge2.not_atom and nedge1.has_argroles() and nedge2.has_argroles():
+            if nedge1.mt == nedge2.mt:
+                common = common_pattern_argroles(nedge1, nedge2)
+                if common:
+                    return common
+
+        # do not combine edges with argroles and edges without them
+        perform_ordered_match = not ((nedge1.not_atom and nedge1.has_argroles())
+                                        or (nedge2.not_atom and nedge2.has_argroles()))
+        # same length
+        if perform_ordered_match and nedge1.not_atom and nedge2.not_atom and len(nedge1) == len(nedge2):
+            subedges = [_common_pattern(subedge1, subedge2) for subedge1, subedge2 in zip(nedge1, nedge2)]
+            if any(subedge is None for subedge in subedges):
+                return None
+            return hedge(subedges)
+        # not same length
+        else:
+            if contains_variable(nedge1) or contains_variable(nedge2):
+                return None
+            etype = common_type((nedge1, nedge2))
+            if etype:
+                return hedge('*/{}'.format(etype))
+            else:
+                return hedge('*')
+
+
+def common_pattern(edge1: Hyperedge, edge2: Hyperedge) -> Hyperedge | None:
+    edge = _common_pattern(edge1, edge2)
+    if is_valid(edge):
+        return edge
+    else:
+        return None

hyperbase/patterns/counter.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from collections import Counter
+
+from hyperbase import hedge
+from hyperbase.hyperedge import Hyperedge
+from hyperbase.patterns.entrypoints import edge_matches_pattern
+
+
+class PatternCounter:
+    def __init__(
+            self,
+            depth: int = 2,
+            count_subedges: bool = True,
+            expansions: set[str] | None = None,
+            match_roots: set[str] | None = None,
+            match_subtypes: set[str] | None = None
+    ) -> None:
+        self.patterns: Counter[Hyperedge | None] = Counter()
+        self.depth = depth
+        self.count_subedges = count_subedges
+        if expansions is None:
+            self.expansions: set[str] = {'*'}
+        else:
+            self.expansions = expansions
+        if match_roots is None:
+            self.match_roots: set[str] = set()
+        else:
+            self.match_roots = match_roots
+        if match_subtypes is None:
+            self.match_subtypes: set[str] = set()
+        else:
+            self.match_subtypes = match_subtypes
+
+    def _matches_expansions(self, edge: Hyperedge) -> bool:
+        for expansion in self.expansions:
+            if edge_matches_pattern(edge, expansion):
+                return True
+        return False
+
+    def _force_subtypes(self, edge: Hyperedge) -> bool:
+        force_subtypes = False
+        for st_pattern in self.match_subtypes:
+            if edge_matches_pattern(edge, st_pattern):
+                force_subtypes = True
+        return force_subtypes
+
+    def _force_root_expansion(self, edge: Hyperedge) -> tuple[bool, bool]:
+        force_root = False
+        force_expansion = False
+        for root_pattern in self.match_roots:
+            if edge_matches_pattern(edge, root_pattern):
+                force_root = True
+                force_expansion = True
+            elif _inner_edge_matches_pattern(edge, root_pattern):
+                force_expansion = True
+        return force_root, force_expansion
+
+    def _list2patterns(
+            self,
+            ledge: list[Hyperedge],
+            depth: int = 1,
+            force_expansion: bool = False,
+            force_root: bool = False,
+            force_subtypes: bool = False
+    ) -> list[list[Hyperedge | None]]:
+        if depth > self.depth:
+            return []
+
+        first = ledge[0]
+
+        f_force_subtypes = force_subtypes | self._force_subtypes(first)
+
+        f_force_root, f_force_expansion = self._force_root_expansion(first)
+        f_force_root |= force_root
+        f_force_expansion |= force_expansion
+        root = force_root | f_force_root
+
+        if f_force_expansion and not first.atom:
+            hpats: list[Hyperedge | None] = []
+        else:
+            hpats = [_edge2pattern(first, root=root, subtype=f_force_subtypes)]
+
+        if not first.atom and (self._matches_expansions(first) or
+                                    f_force_expansion):
+            hpats += self._list2patterns(list(first), depth + 1, force_expansion=f_force_expansion,  # type: ignore[arg-type]
+                                         force_root=f_force_root, force_subtypes=f_force_subtypes)
+        if len(ledge) == 1:
+            patterns: list[list[Hyperedge | None]] = [[hpat] for hpat in hpats]
+        else:
+            patterns = []
+            for pattern in self._list2patterns(
+                    ledge[1:],
+                    depth=depth,
+                    force_expansion=force_expansion,
+                    force_root=force_root,
+                    force_subtypes=force_subtypes
+            ):
+                for hpat in hpats:
+                    patterns.append([hpat] + pattern)
+        return patterns
+
+    def _edge2patterns(self, edge: Hyperedge) -> list[Hyperedge | None]:
+        force_subtypes = self._force_subtypes(edge)
+        force_root, _ = self._force_root_expansion(edge)
+        normalized = edge.normalized()
+        if normalized is None:
+            return []
+        return [
+            hedge(pattern) for pattern in self._list2patterns(
+                list(normalized), force_subtypes=force_subtypes, force_root=force_root
+            )]
+
+    def count(self, edge: Hyperedge | str) -> None:
+        parsed = hedge(edge)
+        if parsed is None:
+            return
+        if parsed.not_atom:
+            if self._matches_expansions(parsed):
+                for pattern in self._edge2patterns(parsed):
+                    self.patterns[pattern] += 1
+            if self.count_subedges:
+                for subedge in parsed:
+                    self.count(subedge)
+
+
+def _edge2pattern(edge: Hyperedge, root: bool = False, subtype: bool = False) -> Hyperedge | None:
+    if root and edge.atom:
+        root_str = edge.root()  # type: ignore[attr-defined]
+    else:
+        root_str = '*'
+    if subtype:
+        et = edge.type()
+    else:
+        et = edge.mtype()
+    pattern = '{}/{}'.format(root_str, et)
+    ar = edge.argroles()
+    if ar == '':
+        return hedge(pattern)
+    else:
+        return hedge('{}.{}'.format(pattern, ar))
+
+
+def _inner_edge_matches_pattern(edge: Hyperedge, pattern: str, hg: object = None) -> bool:
+    if edge.atom:
+        return False
+    for subedge in edge:
+        if edge_matches_pattern(subedge, pattern, hg=hg):
+            return True
+    for subedge in edge:
+        if _inner_edge_matches_pattern(subedge, pattern, hg=hg):
+            return True
+    return False

hyperbase/patterns/entrypoints.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from hyperbase.hyperedge import Hyperedge, hedge
+from hyperbase.patterns.matcher import Matcher
+from hyperbase.patterns.utils import _normalize_fun_patterns
+
+
+def match_pattern(
+        edge: Hyperedge | str | list[object] | tuple[object, ...],
+        pattern: Hyperedge | str | list[object] | tuple[object, ...],
+        curvars: dict[str, Hyperedge] | None = None
+) -> list[dict[str, Hyperedge]]:
+    """Matches an edge to a pattern. This means that, if the edge fits the
+    pattern, then a list of dictionaries will be returned. If the pattern
+    specifies variables, then the returned dictionaries will be populated
+    with the values for each pattern variable. There can be more than one
+    dictionary in the list if there are multiple ways of matching the
+    variables. If the pattern specifies no variables but the edge matches
+    it, then a list with a single empty dictionary is returned. If the
+    edge does not match the pattern, an empty list is returned.
+
+    Patterns are themselves edges. They can match families of edges
+    by employing special atoms:
+
+    -> '\\*' represents a general wildcard (matches any entity)
+
+    -> '.' represents an atomic wildcard (matches any atom)
+
+    -> '(\\*)' represents an edge wildcard (matches any edge)
+
+    -> '...' at the end indicates an open-ended pattern.
+
+    The wildcards ('\\*', '.' and '(\\*)') can be used to specify variables,
+    for example '\\*x', '(CLAIM)' or '.ACTOR'. In case of a match, these
+    variables are assigned the hyperedge they correspond to. For example,
+
+    (1) the edge: (is/Pd (my/Mp name/Cn) mary/Cp)
+    applied to the pattern: (is/Pd (my/Mp name/Cn) \\*NAME)
+    produces the result: [{'NAME', mary/Cp}]
+
+    (2) the edge: (is/Pd (my/Mp name/Cn) mary/Cp)
+    applied to the pattern: (is/Pd (my/Mp name/Cn) (NAME))
+    produces the result: [{}]
+
+    (3) the edge: (is/Pd (my/Mp name/Cn) mary/Cp)
+    applied to the pattern: (is/Pd . \\*NAME)
+    produces the result: []
+    """
+    _edge = hedge(edge)
+    _pattern = hedge(pattern)
+    if _edge is None or _pattern is None:
+        return []
+    _pattern = _normalize_fun_patterns(_pattern)
+
+    matcher: Matcher = Matcher(
+        edge=_edge,
+        pattern=_pattern,
+        curvars=curvars,
+    )
+
+    return matcher.results
+
+
+def edge_matches_pattern(
+        edge: Hyperedge | str | list[object] | tuple[object, ...],
+        pattern: Hyperedge | str | list[object] | tuple[object, ...],
+        **kwargs: object
+) -> bool:
+    """Check if an edge matches a pattern.
+
+    Patterns are themselves edges. They can match families of edges
+    by employing special atoms:
+
+    -> '\\*' represents a general wildcard (matches any entity)
+
+    -> '.' represents an atomic wildcard (matches any atom)
+
+    -> '(\\*)' represents an edge wildcard (matches any edge)
+
+    -> '...' at the end indicates an open-ended pattern.
+
+    The pattern can be any valid hyperedge, including the above special atoms.
+    Examples: (is/Pd hyperbase/C .)
+    (says/Pd * ...)
+    """
+    result = match_pattern(edge, pattern)
+    return len(result) > 0

hyperbase/patterns/matcher.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from collections import Counter
+from typing import Any
+
+from hyperbase import hedge
+from hyperbase.hyperedge import Atom, Hyperedge
+from hyperbase.patterns.argroles import _match_by_argroles
+from hyperbase.patterns.atoms import _matches_atomic_pattern
+from hyperbase.patterns.properties import is_fun_pattern, is_pattern, FUNS
+from hyperbase.patterns.utils import _defun_pattern_argroles, _atoms_and_tok_pos
+from hyperbase.patterns.variables import _varname, _assign_edge_to_var
+
+# tok_pos can be nested lists/ints matching the edge structure
+TokPos = Any
+
+
+class Matcher:
+    def __init__(
+            self,
+            edge: Hyperedge,
+            pattern: Hyperedge,
+            curvars: dict[str, Hyperedge] | None = None,
+            tok_pos: TokPos = None
+    ) -> None:
+        self.results: list[dict[str, Hyperedge]] = self.match(edge, pattern, curvars=curvars, tok_pos=tok_pos)
+
+    def match(
+            self,
+            edge: Hyperedge,
+            pattern: Hyperedge,
+            curvars: dict[str, Hyperedge] | None = None,
+            tok_pos: TokPos = None
+    ) -> list[dict[str, Hyperedge]]:
+        if curvars is None:
+            curvars = {}
+
+        # functional patterns
+        if is_fun_pattern(pattern):
+            return self._match_fun_pat(
+                edge,
+                pattern,
+                curvars,
+                tok_pos=tok_pos
+            )
+
+        # function pattern on edge can never match non-functional pattern
+        if is_fun_pattern(edge):
+            return []
+
+        # atomic patterns
+        if pattern.atom:
+            if _matches_atomic_pattern(edge, pattern):
+                variables: dict[str, Hyperedge] = {}
+                if is_pattern(pattern):
+                    varname = _varname(pattern)
+                    if len(varname) > 0:
+                        variables[varname] = _assign_edge_to_var({**curvars, **variables}, varname, edge)[varname]
+                return [{**curvars, **variables}]
+            else:
+                return []
+
+        min_len = len(pattern)
+        max_len: int | float = min_len
+        # open-ended?
+        if pattern[-1].to_str() == '...':
+            new_pattern = hedge(pattern[:-1])
+            if new_pattern is None:
+                return []
+            pattern = new_pattern
+            min_len -= 1
+            max_len = float('inf')
+
+        result: list[dict[str, Hyperedge]] = [{}]
+        argroles_posopt = _defun_pattern_argroles(pattern)[0].argroles().split('-')[0]
+        if len(argroles_posopt) > 0 and argroles_posopt[0] == '{':
+            match_by_order = False
+            argroles_posopt = argroles_posopt[1:-1]
+        else:
+            match_by_order = True
+        argroles = argroles_posopt.split(',')[0]
+        argroles_opt = argroles_posopt.replace(',', '')
+
+        if len(argroles) > 0:
+            min_len = 1 + len(argroles)
+            max_len = float('inf')
+        else:
+            match_by_order = True
+
+        if len(edge) < min_len or len(edge) > max_len:
+            return []
+
+        # match by order
+        if match_by_order:
+            for i, pitem in enumerate(pattern):
+                eitem = edge[i]
+                _result: list[dict[str, Hyperedge]] = []
+
+                for variables in result:
+                    if pitem.atom:
+                        varname = _varname(pitem)
+                        if _matches_atomic_pattern(eitem, pitem):
+                            if len(varname) > 0 and varname[0].isupper():
+                                variables[varname] = _assign_edge_to_var(
+                                    {**curvars, **variables}, varname, eitem)[varname]
+                        else:
+                            continue
+                        _result.append(variables)
+                    else:
+                        tok_pos_item = None
+                        if tok_pos is not None:
+                            try:
+                                assert len(tok_pos) > i
+                            except AssertionError:
+                                raise RuntimeError(f"Index '{i}' in tok_pos '{tok_pos}' is out of range")
+                            tok_pos_item = tok_pos[i]
+                        _result += self.match(
+                            eitem,
+                            pitem,
+                            {**curvars, **variables},
+                            tok_pos=tok_pos_item
+                        )
+                result = _result
+        # match by argroles
+        else:
+            result = []
+            # match connector first
+            ctok_pos = tok_pos[0] if tok_pos else None
+            if self.match(edge[0], pattern[0], curvars, tok_pos=ctok_pos):
+                role_counts = Counter(argroles_opt).most_common()
+                unknown_roles = (len(pattern) - 1) - len(argroles_opt)
+                if unknown_roles > 0:
+                    role_counts.append(('*', unknown_roles))
+                # add connector pseudo-argrole
+                role_counts = [('X', 1)] + role_counts
+                result = _match_by_argroles(
+                    self,
+                    edge,
+                    pattern,
+                    role_counts,
+                    len(argroles),
+                    curvars=curvars,
+                    tok_pos=tok_pos
+                )
+
+        unique_vars: list[dict[str, Hyperedge]] = []
+        for variables in result:
+            v = {**curvars, **variables}
+            if v not in unique_vars:
+                unique_vars.append(v)
+        return unique_vars
+
+    def _match_atoms(
+            self,
+            atom_patterns: tuple[Hyperedge, ...],
+            atoms: set[Atom] | list[Atom],
+            curvars: dict[str, Hyperedge],
+            atoms_tok_pos: list[Any] | None = None,
+            matched_atoms: list[Atom] | None = None
+    ) -> list[dict[str, Hyperedge]]:
+        if matched_atoms is None:
+            matched_atoms = []
+
+        if len(atom_patterns) == 0:
+            return [curvars]
+
+        results: list[dict[str, Hyperedge]] = []
+        atom_pattern = atom_patterns[0]
+
+        for atom_pos, atom in enumerate(atoms):
+            if atom not in matched_atoms:
+                tok_pos = atoms_tok_pos[atom_pos] if atoms_tok_pos else None
+                svars = self.match(atom, atom_pattern, curvars, tok_pos=tok_pos)
+                for variables in svars:
+                    results += self._match_atoms(
+                        atom_patterns[1:],
+                        atoms,
+                        {**curvars, **variables},
+                        atoms_tok_pos=atoms_tok_pos,
+                        matched_atoms=matched_atoms + [atom]
+                    )
+
+        return results
+
+    def _match_fun_pat(
+            self,
+            edge: Hyperedge,
+            fun_pattern: Hyperedge,
+            curvars: dict[str, Hyperedge],
+            tok_pos: TokPos = None
+    ) -> list[dict[str, Hyperedge]]:
+        fun = fun_pattern[0].root()
+
+        try:
+            assert fun in FUNS
+        except AssertionError:
+                raise ValueError(f"Unknown pattern function: {fun}")
+
+        if fun == 'var':
+            if len(fun_pattern) != 3:
+                raise RuntimeError('var pattern function must have two arguments')
+            pattern = fun_pattern[1]
+            var_name = fun_pattern[2].root()
+            if edge.not_atom and str(edge[0]) == 'var' and len(edge) == 3 and str(edge[2]) == var_name:
+                this_var = _assign_edge_to_var(curvars, var_name, edge[1])
+                return self.match(
+                    edge[1],
+                    pattern,
+                    curvars={**curvars, **this_var},
+                    tok_pos=tok_pos
+                )
+            else:
+                this_var = _assign_edge_to_var(curvars, var_name, edge)
+                return self.match(
+                    edge,
+                    pattern,
+                    curvars={**curvars, **this_var},
+                    tok_pos=tok_pos
+                )
+        elif fun == 'atoms':
+            if tok_pos:
+                atoms_list, atoms_tok_pos = _atoms_and_tok_pos(edge, tok_pos)
+            else:
+                atoms_list = list(edge.atoms())
+                atoms_tok_pos = None
+            atom_patterns = fun_pattern[1:]
+            return self._match_atoms(
+                atom_patterns,
+                atoms_list,
+                curvars,
+                atoms_tok_pos=atoms_tok_pos
+            )
+        elif fun == 'any':
+            for pattern in fun_pattern[1:]:
+                matches = self.match(
+                    edge,
+                    pattern,
+                    curvars=curvars,
+                    tok_pos=tok_pos
+                )
+                if len(matches) > 0:
+                    return matches
+            return []
+        else:
+            raise NotImplementedError(f"Pattern function '{fun}' not implemented.")