[fix] invalid link variables

Author: tswsxk

EduNLP/Formula/Formula.py

@@ -14,8 +14,36 @@
 
 
 class Formula(object):
+    """
+    Examples
+    --------
+    >>> f = Formula("x")
+    >>> f
+    <Formula: x>
+    >>> f.ast
+    [{'val': {'id': 0, 'type': 'mathord', 'text': 'x', 'role': None}, \
+'structure': {'bro': [None, None], 'child': None, 'father': None, 'forest': None}}]
+    >>> f.elements
+    [{'id': 0, 'type': 'mathord', 'text': 'x', 'role': None}]
+    >>> f.variable_standardization(inplace=True)
+    <Formula: x>
+    >>> f.elements
+    [{'id': 0, 'type': 'mathord', 'text': 'x', 'role': None, 'var': 0}]
+    """
+
     def __init__(self, formula: (str, List[Dict]), variable_standardization=False, const_mathord=None,
                  *args, **kwargs):
+        """
+
+        Parameters
+        ----------
+        formula: str or List[Dict]
+            latex formula string or the parsed abstracted syntax tree
+        variable_standardization
+        const_mathord
+        args
+        kwargs
+        """
         self._formula = formula
         self._ast = None
         self.reset_ast(
@@ -43,11 +71,15 @@ def variable_standardization(self, inplace=False, const_mathord=None, variable_c
             return Formula(ast_tree, is_str=False)
 
     @property
-    def element(self):
+    def ast(self):
         return self._ast
 
     @property
-    def ast(self) -> (nx.Graph, nx.DiGraph):
+    def elements(self):
+        return [self.ast_graph.nodes[node] for node in self.ast_graph.nodes]
+
+    @property
+    def ast_graph(self) -> (nx.Graph, nx.DiGraph):
         edges = [(edge[0], edge[1]) for edge in get_edges(self._ast) if edge[2] == 3]
         tree = nx.DiGraph()
         for node in self._ast:
@@ -67,8 +99,9 @@ def __repr__(self):
         else:
             return super(Formula, self).__repr__()
 
-    def reset_ast(self, formula_ensure_str=True, variable_standardization=False, const_mathord=None, *args, **kwargs):
-        if formula_ensure_str is True and self.resetable is True:
+    def reset_ast(self, formula_ensure_str: bool = True, variable_standardization=False, const_mathord=None, *args,
+                  **kwargs):
+        if formula_ensure_str is True and self.resetable is False:
             raise TypeError("formula must be str, now is %s" % type(self._formula))
         self._ast = str2ast(self._formula, *args, **kwargs) if isinstance(self._formula, str) else self._formula
         if variable_standardization:
@@ -82,34 +115,49 @@ def resetable(self):
 
 
 class FormulaGroup(object):
+    """
+    Examples
+    ---------
+    >>> fg = FormulaGroup(["x + y", "y + x", "z + x"])
+    >>> fg
+    <FormulaGroup: <Formula: x + y>;<Formula: y + x>;<Formula: z + x>>
+    >>> fg = FormulaGroup(["x + y", Formula("y + x"), "z + x"])
+    >>> fg
+    <FormulaGroup: <Formula: x + y>;<Formula: y + x>;<Formula: z + x>>
+    >>> fg = FormulaGroup(["x", Formula("y"), "x"])
+    >>> fg.elements
+    [{'id': 0, 'type': 'mathord', 'text': 'x', 'role': None}, {'id': 1, 'type': 'mathord', 'text': 'y', 'role': None},\
+ {'id': 2, 'type': 'mathord', 'text': 'x', 'role': None}]
+    >>> fg = FormulaGroup(["x", Formula("y"), "x"], variable_standardization=True)
+    >>> fg.elements
+    [{'id': 0, 'type': 'mathord', 'text': 'x', 'role': None, 'var': 0}, \
+{'id': 1, 'type': 'mathord', 'text': 'y', 'role': None, 'var': 1}, \
+{'id': 2, 'type': 'mathord', 'text': 'x', 'role': None, 'var': 0}]
+    """
+
     def __init__(self,
-                 formula_list: (List[(str, Formula, dict)]),
+                 formula_list: (list, List[str], List[Formula]),
                  variable_standardization=False,
                  const_mathord=None,
                  detach=True
                  ):
-        """
-
-        Parameters
-        ----------
-        formula_list: List[str]
-        """
         forest = []
         self._formulas = []
-        for index in range(0, len(formula_list)):
-            formula = formula_list[index]
+        for formula in formula_list:
             if isinstance(formula, str):
-                tree = str2ast(
+                formula = Formula(
                     formula,
                     forest_begin=len(forest),
                 )
-                self._formulas.append(Formula(tree))
+                self._formulas.append(formula)
+                tree = formula.ast
             elif isinstance(formula, Formula):
                 if detach:
                     formula = deepcopy(formula)
                 tree = formula.reset_ast(
                     formula_ensure_str=True,
                     variable_standardization=False,
+                    forest_begin=len(forest),
                 )
                 self._formulas.append(formula)
             else:
@@ -149,11 +197,15 @@ def __repr__(self):
         return "<FormulaGroup: %s>" % ";".join([repr(_formula) for _formula in self._formulas])
 
     @property
-    def element(self):
+    def ast(self):
         return self._forest
 
     @property
-    def ast(self) -> (nx.Graph, nx.DiGraph):
+    def elements(self):
+        return [self.ast_graph.nodes[node] for node in self.ast_graph.nodes]
+
+    @property
+    def ast_graph(self) -> (nx.Graph, nx.DiGraph):
         edges = [(edge[0], edge[1]) for edge in get_edges(self._forest) if edge[2] == 3]
         tree = nx.DiGraph()
         for node in self._forest:

EduNLP/SIF/tokenization/formula/ast_token.py

@@ -79,12 +79,12 @@ def ast_tokenize(formula, ord2token=False, var_numbering=False, return_type="for
     <Formula: {x + y}^\\frac{\\pi}{2} + 1 = x>
     """
     if return_type == "list":
-        ast = Formula(formula, variable_standardization=True).ast
+        ast = Formula(formula, variable_standardization=True).ast_graph
         return traversal_formula(ast, ord2token=ord2token, var_numbering=var_numbering)
     elif return_type == "formula":
         return Formula(formula)
     elif return_type == "ast":
-        return Formula(formula).ast
+        return Formula(formula).ast_graph
     else:
         raise ValueError()
 

EduNLP/SIF/tokenization/tokenization.py

@@ -2,7 +2,7 @@
 # 2021/5/18 @ tongshiwei
 
 import itertools as it
-from EduNLP.Formula import link_variable, Formula
+from EduNLP.Formula import link_formulas as _link_formulas, Formula
 from ..constants import Symbol, TEXT_SYMBOL, FIGURE_SYMBOL, FORMULA_SYMBOL, QUES_MARK_SYMBOL
 from ..segment import (SegmentList, TextSegment, FigureSegment, LatexFormulaSegment, FigureFormulaSegment,
                        QuesMarkSegment, Figure)
@@ -26,15 +26,9 @@ def __init__(self, segment_list: SegmentList, text_params=None, formula_params=N
 
     def _variable_standardization(self):
         if self.formula_tokenize_method == "ast":
-            ast_formulas = [self._tokens[i].element for i in self._formula_tokens if
-                            isinstance(self._tokens[i], Formula)]
+            ast_formulas = [self._tokens[i] for i in self._formula_tokens if isinstance(self._tokens[i], Formula)]
             if ast_formulas:
-                link_variable(list(it.chain(*ast_formulas)))
-                self.variable_standardization()
-
-    def variable_standardization(self):
-        for i in self._formula_tokens:
-            self._tokens[i].variable_standardization(inplace=True)
+                _link_formulas(*ast_formulas)
 
     @property
     def tokens(self):
@@ -114,9 +108,9 @@ def text_tokens(self):
     def __add_token(self, token, tokens):
         if isinstance(token, Formula):
             if self.formula_params.get("return_type") == "list":
-                tokens.extend(formula.traversal_formula(token.ast, **self.formula_params))
+                tokens.extend(formula.traversal_formula(token.ast_graph, **self.formula_params))
             elif self.formula_params.get("return_type") == "ast":
-                tokens.append(token.ast)
+                tokens.append(token.ast_graph)
             else:
                 tokens.append(token)
         elif isinstance(token, Figure):
@@ -161,10 +155,5 @@ def link_formulas(*token_list: TokenList):
     ast_formulas = []
     for tl in token_list:
         if tl.formula_tokenize_method == "ast":
-            ast_formulas.extend([
-                token.element for token in tl.inner_formula_tokens
-                if isinstance(token, Formula)
-            ])
-    link_variable(list(it.chain(*ast_formulas)))
-    for tl in token_list:
-        tl.variable_standardization()
+            ast_formulas.extend([token for token in tl.inner_formula_tokens if isinstance(token, Formula)])
+    _link_formulas(*ast_formulas)