base ¶

def add(self, atom):
    """
    Adds an Atom to the atom space. Must be implemented in derived classes.
    """
    raise RuntimeError("Space::add() is not implemented")

def atom_count(self):
    """
    Counts the number of atoms in the atom space. Optional for derived classes.
    """
    None

def atoms_iter(self):
    """
    Returns an iterator over atoms in the Space. Optional for derived classes.
    """
    None

def query(self, query_atom):
    """
    Performs the specified query on the Space.
    Should be overridden to return a BindingsSet as the result of the query.
    """
    raise RuntimeError("Space::query() is not implemented")

def remove(self, atom):
    """
    Removes an Atom from the atom space. Must be implemented in derived classes.
    """
    raise RuntimeError("Space::remove() is not implemented")

def replace(self, atom, replacement):
    """
    Replaces an Atom from the atom space. Must be implemented in derived classes.
    """
    raise RuntimeError("Space::replace() is not implemented")

def add(self, atom):
    """
    Adds an Atom to the atom space.
    """
    self.gspace.add_atom(atom)

def atom_count(self):
    """
    Counts the number of Atoms in the atom space.
    """
    return self.gspace.atom_count()

def atoms_iter(self):
    """
    Returns an iterator over atoms in the atom space.
    """
    return iter(self.gspace.get_atoms())

def query(self, query_atom):
    """
    Delegates the query to the underlying native GroundingSpace
    and returns the result BindingsSet
    """
    return self.gspace.query(query_atom)

def remove(self, atom):
    """
    Removes an Atom from the atom space.
    """
    return self.gspace.remove_atom(atom)

def replace(self, from_atom, to_atom):
    """
    Replaces an Atom in the atom space.
    """
    return self.gspace.replace_atom(from_atom, to_atom)

def __del__(self):
    """Free the underlying CSpace object """
    hp.space_free(self.cspace)

def __eq__(self, other):
    """Compare two SpaceRef objects for equality, based on their underlying spaces."""
    return hp.space_eq(self.cspace, other.cspace)

def add_atom(self, atom):
    """
    Add an Atom to the Space.
    """
    hp.space_add(self.cspace, atom.catom)

def atom_count(self):
    """
    Returns the number of Atoms in the Space, or -1 if it cannot be readily computed.
    """
    return hp.space_atom_count(self.cspace)

def copy(self):
    """
    Returns a new copy of the SpaceRef, referencing the same underlying Space.
    """
    return self

def get_atoms(self):
    """
    Returns a list of all Atoms in the Space, or None if that is impossible.
    """
    res = hp.space_list(self.cspace)
    if res == None:
        return None
    result = []
    for r in res:
        result.append(Atom._from_catom(r))
    return result

def get_payload(self):
    """
    Returns the Space object referenced by the SpaceRef, or None if the object does not have a
    direct Python interface.
    """
    return hp.space_get_payload(self.cspace)

def query(self, pattern):
    """
    Performs the specified query on the Space, and returns the result as a BindingsSet.
    """
    result = hp.space_query(self.cspace, pattern.catom)
    return BindingsSet(result)

def remove_atom(self, atom):
    """
    Delete the specified Atom from the Space.
    """
    return hp.space_remove(self.cspace, atom.catom)

def replace_atom(self, atom, replacement):
    """
    Replaces the specified Atom, if it exists in the Space, with the supplied replacement.
    """
    return hp.space_replace(self.cspace, atom.catom, replacement.catom)

def subst(self, pattern, templ):
    """
    Performs a substitution within the Space, based on a pattern and a template.
    """
    return [Atom._from_catom(catom) for catom in
            hp.space_subst(self.cspace, pattern.catom,
                                     templ.catom)]

def get_result(self):
    """
    Retrieves the final outcome of the interpretation plan.
    """
    if self.has_next():
        raise RuntimeError("Plan execution is not finished")
    return hp.step_get_result(self.step_result)

def get_step_result(self):
    """
    Gets the current result of the interpretation plan.
    """
    return self.step_result

def has_next(self):
    """
    Checks if there are more steps to execute in the interpretation plan.
    """
    return hp.step_has_next(self.step_result)

def next(self):
    """
    Executes the next step in the interpretation plan.
    """
    if not self.has_next():
        raise StopIteration()
    self.step_result = hp.interpret_step(self.step_result)

def parse(self, tokenizer):
    """
    Parses the S-expression using the provided Tokenizer.
    """
    catom = self.cparser.parse(tokenizer.ctokenizer)
    if (catom is None):
        err_str = self.cparser.sexpr_parser_err_str()
        if (err_str is None):
            return None
        else:
            raise SyntaxError(err_str)
    else:
        return Atom._from_catom(catom)

def parse_to_syntax_tree(self):
    """
    Parses the S-expression into a SyntaxNode representing the top-level of a syntax tree.
    """
    cnode = self.cparser.parse_to_syntax_tree()
    return SyntaxNode(cnode) if cnode is not None else None

def __del__(self):
    """Free the underlying CSpace object """
    hp.space_free(self.cspace)

def __eq__(self, other):
    """Compare two SpaceRef objects for equality, based on their underlying spaces."""
    return hp.space_eq(self.cspace, other.cspace)

def add_atom(self, atom):
    """
    Add an Atom to the Space.
    """
    hp.space_add(self.cspace, atom.catom)

def atom_count(self):
    """
    Returns the number of Atoms in the Space, or -1 if it cannot be readily computed.
    """
    return hp.space_atom_count(self.cspace)

def copy(self):
    """
    Returns a new copy of the SpaceRef, referencing the same underlying Space.
    """
    return self

def get_atoms(self):
    """
    Returns a list of all Atoms in the Space, or None if that is impossible.
    """
    res = hp.space_list(self.cspace)
    if res == None:
        return None
    result = []
    for r in res:
        result.append(Atom._from_catom(r))
    return result

def get_payload(self):
    """
    Returns the Space object referenced by the SpaceRef, or None if the object does not have a
    direct Python interface.
    """
    return hp.space_get_payload(self.cspace)

def query(self, pattern):
    """
    Performs the specified query on the Space, and returns the result as a BindingsSet.
    """
    result = hp.space_query(self.cspace, pattern.catom)
    return BindingsSet(result)

def remove_atom(self, atom):
    """
    Delete the specified Atom from the Space.
    """
    return hp.space_remove(self.cspace, atom.catom)

def replace_atom(self, atom, replacement):
    """
    Replaces the specified Atom, if it exists in the Space, with the supplied replacement.
    """
    return hp.space_replace(self.cspace, atom.catom, replacement.catom)

def subst(self, pattern, templ):
    """
    Performs a substitution within the Space, based on a pattern and a template.
    """
    return [Atom._from_catom(catom) for catom in
            hp.space_subst(self.cspace, pattern.catom,
                                     templ.catom)]

def __del__(self):
    """
    Destructor for the SyntaxNode
    """
    hp.syntax_node_free(self.cnode)

def get_type(self):
    """
    Returns the type of a SyntaxNode
    """
    return hp.syntax_node_type(self.cnode)

def src_range(self):
    """
    Returns the range of offsets into the source code of the text represented by the SyntaxNode
    """
    range_tuple = hp.syntax_node_src_range(self.cnode)
    return range(range_tuple[0], range_tuple[1])

def unroll(self):
    """
    Returns a list of all leaf nodes recursively contained within a SyntaxNode
    """
    syntax_nodes = []
    for cnode in hp.syntax_node_unroll(self.cnode):
        syntax_nodes.append(SyntaxNode(cnode))
    return syntax_nodes

def __del__(self):
    """
    Destructor that frees the underlying resources when the Tokenizer instance is destroyed.
    """
    hp.tokenizer_free(self.ctokenizer)

def register_token(self, regex, constr):
    """
    Registers a new custom Token in the Tokenizer based on a regular expression.

    Parameters:
    ----------
    regex:
       A string representing the regular expression to match incoming text.
       Hyperon uses the Rust RegEx engine and syntax.
   constr:
       A constructor function for generating a new atom when the regex is triggered.
   """
    hp.tokenizer_register_token(self.ctokenizer, regex, constr)