add fcfg annotations

Author: bygu4

pyformlang/fcfg/fcfg.py

@@ -1,13 +1,17 @@
 """Feature Context-Free Grammar"""
-import string
-from typing import Iterable, AbstractSet
 
-from pyformlang.cfg import CFG, Terminal, Epsilon, Variable
-from pyformlang.cfg.cfg import is_special_text, EPSILON_SYMBOLS, NotParsableException
+from typing import List, Set, Tuple, AbstractSet, Iterable, Optional, Any
+from string import ascii_uppercase
+
+from pyformlang.cfg import CFG, Terminal, Variable, Production, Epsilon
+from pyformlang.cfg.cfg import is_special_text, \
+    EPSILON_SYMBOLS, NotParsableException
+from pyformlang.cfg.cfg_object import CFGObject
 from pyformlang.cfg.parse_tree import ParseTree
 from pyformlang.cfg.utils import to_terminal
 from pyformlang.fcfg.feature_production import FeatureProduction
-from pyformlang.fcfg.feature_structure import FeatureStructure, FeatureStructuresNotCompatibleException
+from pyformlang.fcfg.feature_structure import FeatureStructure, \
+    FeatureStructuresNotCompatibleException
 from pyformlang.fcfg.state import State, StateProcessed
 
 
@@ -58,21 +62,28 @@ def __init__(self,
                  variables: AbstractSet[Variable] = None,
                  terminals: AbstractSet[Terminal] = None,
                  start_symbol: Variable = None,
-                 productions: Iterable[FeatureProduction] = None):
+                 productions: Iterable[FeatureProduction] = None) -> None:
         super().__init__(variables, terminals, start_symbol, productions)
+        self._productions: Set[FeatureProduction] # type: ignore
 
-    def __predictor(self, state, chart, processed):
+    def __predictor(self,
+                    state: State,
+                    chart: List[List[State]],
+                    processed: StateProcessed) -> None:
         # We have an incomplete state and the next token is a variable
         # We must ask to process the variable with another rule
         end_idx = state.positions[1]
         next_var = state.production.body[state.positions[2]]
-        for production in self.productions:
+        for production in self._productions:
             if production.head == next_var:
-                new_state = State(production, (end_idx, end_idx, 0), production.features, ParseTree(production.head))
+                new_state = State(production,
+                                  (end_idx, end_idx, 0),
+                                  production.features,
+                                  ParseTree(production.head))
                 if processed.add(end_idx, new_state):
                     chart[end_idx].append(new_state)
 
-    def contains(self, word: Iterable[Terminal]) -> bool:
+    def contains(self, word: Iterable[Any]) -> bool:
         """ Gives the membership of a word to the grammar
 
         Parameters
@@ -85,9 +96,10 @@ def contains(self, word: Iterable[Terminal]) -> bool:
         contains : bool
             Whether word if in the FCFG or not
         """
+        word = [to_terminal(x) for x in word if x != Epsilon()]
         return self._get_final_state(word) is not None
 
-    def get_parse_tree(self, word: Iterable[Terminal]) -> ParseTree:
+    def get_parse_tree(self, word: Iterable[Any]) -> ParseTree:
         """ Gives the parse tree for a sentence, if possible
 
         Parameters
@@ -105,20 +117,30 @@ def get_parse_tree(self, word: Iterable[Terminal]) -> ParseTree:
         NotParsableException
             When the word is not parsable.
         """
+        word = [to_terminal(x) for x in word if x != Epsilon()]
         final_state = self._get_final_state(word)
         if final_state is None:
             raise NotParsableException()
         return final_state.parse_tree
 
-    def _get_final_state(self, word: Iterable[Terminal]):
-        word = [to_terminal(x) for x in word if x != Epsilon()]
+    def _get_final_state(self, word: List[Terminal]) -> Optional[State]:
         chart = [[] for _ in range(len(word) + 1)]
-        # Processed[i] contains all production rule that are currently working until i.
+        # Processed[i] contains all production rule \
+        # that are currently working until i.
         processed = StateProcessed(len(word) + 1)
         gamma = Variable("Gamma")
-        dummy_rule = FeatureProduction(gamma, [self.start_symbol], FeatureStructure(), [FeatureStructure()])
+        production_body: List[CFGObject] = []
+        if self.start_symbol is not None:
+            production_body.append(self.start_symbol)
+        dummy_rule = FeatureProduction(gamma,
+                                       production_body,
+                                       FeatureStructure(),
+                                       [FeatureStructure()])
         # State = (rule, [begin, end, dot position, diag)
-        first_state = State(dummy_rule, (0, 0, 0), dummy_rule.features, ParseTree("BEGIN"))
+        first_state = State(dummy_rule,
+                            (0, 0, 0),
+                            dummy_rule.features,
+                            ParseTree("BEGIN"))
         chart[0].append(first_state)
         processed.add(0, first_state)
         for i in range(len(chart) - 1):
@@ -136,19 +158,26 @@ def _get_final_state(self, word: Iterable[Terminal]):
             if not state.is_incomplete():
                 _completer(state, chart, processed)
         for state in processed.generator(len(word)):
-            if state.positions[0] == 0 and not state.is_incomplete() and state.production.head == self.start_symbol:
+            if state.positions[0] == 0 \
+                    and not state.is_incomplete() \
+                    and state.production.head == self.start_symbol:
                 return state
         return None
 
     @classmethod
-    def _read_line(cls, line, productions, terminals, variables):
+    def _read_line(cls,
+                   line: str,
+                   productions: Set[Production],
+                   terminals: Set[Terminal],
+                   variables: Set[Variable]) -> None:
         structure_variables = {}
         head_s, body_s = line.split("->")
         head_text = head_s.strip()
         if is_special_text(head_text):
             head_text = head_text[5:-1]
         head_text, head_conditions = _split_text_conditions(head_text)
-        head_fs = FeatureStructure.from_text(head_conditions, structure_variables)
+        head_fs = FeatureStructure.from_text(
+            head_conditions, structure_variables)
         head = Variable(head_text)
         variables.add(head)
         all_body_fs = []
@@ -160,10 +189,12 @@ def _read_line(cls, line, productions, terminals, variables):
                     body_component = body_component[5:-1]
                 else:
                     type_component = ""
-                if body_component[0] in string.ascii_uppercase or \
+                if body_component[0] in ascii_uppercase or \
                         type_component == "VAR":
-                    body_component, body_conditions = _split_text_conditions(body_component)
-                    body_fs = FeatureStructure.from_text(body_conditions, structure_variables)
+                    body_component, body_conditions = \
+                        _split_text_conditions(body_component)
+                    body_fs = FeatureStructure.from_text(
+                        body_conditions, structure_variables)
                     all_body_fs.append(body_fs)
                     body_var = Variable(body_component)
                     variables.add(body_var)
@@ -178,7 +209,7 @@ def _read_line(cls, line, productions, terminals, variables):
             productions.add(production)
 
 
-def _split_text_conditions(head_text):
+def _split_text_conditions(head_text: str) -> Tuple[str, str]:
     if head_text[-1] != "]":
         return head_text, ""
     idx = head_text.find("[")
@@ -187,36 +218,48 @@ def _split_text_conditions(head_text):
     return head_text[:idx], head_text[idx+1:-1]
 
 
-def _scanner(state, chart, processed):
+def _scanner(state: State,
+             chart: List[List[State]],
+             processed: StateProcessed) -> None:
     # We have an incomplete state and the next token is the word given as input
     # We move the end token and the dot token by one.
     end_idx = state.positions[1]
-    state.parse_tree.sons.append(ParseTree(state.production.body[state.positions[2]]))
-    new_state = State(state.production, (state.positions[0], end_idx + 1, state.positions[2] + 1),
-                      state.feature_stucture, state.parse_tree)
+    state.parse_tree.sons.append(
+        ParseTree(state.production.body[state.positions[2]]))
+    new_state = State(state.production,
+                      (state.positions[0], end_idx + 1, state.positions[2] + 1),
+                      state.feature_stucture,
+                      state.parse_tree)
     if processed.add(end_idx + 1, new_state):
         chart[end_idx + 1].append(new_state)
 
 
-def _completer(state, chart, processed):
-    # We have a complete state. We must check if it helps to move another state forward.
+def _completer(state: State,
+               chart: List[List[State]],
+               processed: StateProcessed) -> None:
+    # We have a complete state.
+    # We must check if it helps to move another state forward.
     begin_idx = state.positions[0]
     head = state.production.head
     for next_state in processed.generator(begin_idx):
         # next_state[1][1] == begin_idx always true
-        if next_state.is_incomplete() and next_state.production.body[next_state.positions[2]] == head:
+        if next_state.is_incomplete() \
+            and next_state.production.body[next_state.positions[2]] == head:
             try:
                 copy_left = state.feature_stucture.copy()
                 copy_left = copy_left.get_feature_by_path(["head"])
                 copy_right = next_state.feature_stucture.copy()
-                copy_right_considered = copy_right.get_feature_by_path([str(next_state.positions[2])])
+                copy_right_considered = copy_right.get_feature_by_path(
+                    [str(next_state.positions[2])])
                 copy_right_considered.unify(copy_left)
             except FeatureStructuresNotCompatibleException:
                 continue
             parse_tree = next_state.parse_tree
             parse_tree.sons.append(state.parse_tree)
             new_state = State(next_state.production,
-                              (next_state.positions[0], state.positions[1], next_state.positions[2] + 1),
+                              (next_state.positions[0],
+                               state.positions[1],
+                               next_state.positions[2] + 1),
                               copy_right, parse_tree)
             if processed.add(state.positions[1], new_state):
                 chart[state.positions[1]].append(new_state)

pyformlang/fcfg/feature_production.py

@@ -1,5 +1,6 @@
 """Production rules with features"""
-from typing import List
+
+from typing import List, Iterable
 
 from pyformlang.cfg import Production, Variable
 from pyformlang.cfg.cfg_object import CFGObject
@@ -18,22 +19,28 @@ class FeatureProduction(Production):
     head_feature : :class:`~pyformlang.fcfg.FeatureStructure`
         The feature structure of the head
     body_features : Iterable of :class:`~pyformlang.fcfg.FeatureStructure`
-        The feature structures of the elements of the body. Must be the same size as the body.
+        The feature structures of the elements of the body.
+        Must be the same size as the body.
     """
 
-    def __init__(self, head: Variable, body: List[CFGObject], head_feature, body_features, filtering=True):
+    def __init__(self,
+                 head: Variable,
+                 body: List[CFGObject],
+                 head_feature: FeatureStructure,
+                 body_features: Iterable[FeatureStructure],
+                 filtering: bool = True) -> None:
         super().__init__(head, body, filtering)
         self._features = FeatureStructure()
         self._features.add_content("head", head_feature)
         for i, feature_structure in enumerate(body_features):
             self._features.add_content(str(i), feature_structure)
 
     @property
-    def features(self):
+    def features(self) -> FeatureStructure:
         """The merged features of the production rules"""
         return self._features
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         res = [self.head.to_text()]
         cond_head = str(self._features.get_feature_by_path(["head"]))
         if cond_head: