add production and start symbol adding for cfg, correct epsilon equality

Author: bygu4

pyformlang/cfg/cfg.py

@@ -57,23 +57,13 @@ def __init__(self,
             start_symbol = to_variable(start_symbol)
             self._variables.add(start_symbol)
         self._start_symbol = start_symbol
-        if productions is not None:
-            productions = set(productions)
-        self._productions = productions or set()
-        for production in self._productions:
-            self.__initialize_production_in_cfg(production)
+        self._productions = set()
+        for production in productions or set():
+            self.add_production(production)
         self._impacts: Dict[CFGObject, List[Tuple[CFGObject, int]]] = {}
         self._remaining_lists: Dict[CFGObject, List[int]] = {}
         self._added_impacts: Set[CFGObject] = set()
 
-    def __initialize_production_in_cfg(self, production: Production) -> None:
-        self._variables.add(production.head)
-        for cfg_object in production.body:
-            if isinstance(cfg_object, Terminal):
-                self._terminals.add(cfg_object)
-            elif isinstance(cfg_object, Variable):
-                self._variables.add(cfg_object)
-
     def get_generating_symbols(self) -> Set[CFGObject]:
         """ Gives the objects which are generating in the CFG
 
@@ -846,12 +836,13 @@ def get_words(self, max_length: int = -1) -> Iterable[List[Terminal]]:
         for production in productions:
             body = production.body
             if len(body) == 1 and isinstance(body[0], Terminal):
+                word = [body[0]]
                 if len(gen_d[production.head]) == 1:
                     gen_d[production.head].append([])
-                if [body[0]] not in gen_d[production.head][-1]:
-                    gen_d[production.head][-1].append([body[0]])
+                if word not in gen_d[production.head][-1]:
+                    gen_d[production.head][-1].append(word)
                     if production.head == cfg.start_symbol:
-                        yield [body[0]]
+                        yield word
         # Complete what is missing
         current_length = 2
         total_no_modification = 0

pyformlang/cfg/cfg_variable_converter.py

@@ -2,23 +2,23 @@
 
 from typing import Dict, List, AbstractSet, Tuple, Optional, Hashable
 
-from ..objects.cfg_objects import Variable, CFGConvertible
+from ..objects.cfg_objects import Variable, CFGObjectConvertible
 
 
 class CFGVariableConverter:
     """A CFG Variable Converter"""
 
     def __init__(self,
-                 states: AbstractSet[CFGConvertible],
-                 stack_symbols: AbstractSet[CFGConvertible]) -> None:
+                 states: AbstractSet[CFGObjectConvertible],
+                 stack_symbols: AbstractSet[CFGObjectConvertible]) -> None:
         self._counter = 0
-        self._inverse_states_d: Dict[CFGConvertible, int] = {}
+        self._inverse_states_d: Dict[CFGObjectConvertible, int] = {}
         self._counter_state = 0
         for self._counter_state, state in enumerate(states):
             self._inverse_states_d[state] = self._counter_state
             state.index_cfg_converter = self._counter_state
         self._counter_state += 1
-        self._inverse_stack_symbol_d: Dict[CFGConvertible, int] = {}
+        self._inverse_stack_symbol_d: Dict[CFGObjectConvertible, int] = {}
         self._counter_symbol = 0
         for self._counter_symbol, symbol in enumerate(stack_symbols):
             self._inverse_stack_symbol_d[symbol] = self._counter_symbol
@@ -29,7 +29,7 @@ def __init__(self,
                 for _ in range(len(stack_symbols))] for _ in
                range(len(states))]
 
-    def _get_state_index(self, state: CFGConvertible) -> int:
+    def _get_state_index(self, state: CFGObjectConvertible) -> int:
         """Get the state index"""
         if state.index_cfg_converter is None:
             if state not in self._inverse_states_d:
@@ -38,7 +38,7 @@ def _get_state_index(self, state: CFGConvertible) -> int:
             state.index_cfg_converter = self._inverse_states_d[state]
         return state.index_cfg_converter
 
-    def _get_symbol_index(self, symbol: CFGConvertible) -> int:
+    def _get_symbol_index(self, symbol: CFGObjectConvertible) -> int:
         """Get the symbol index"""
         if symbol.index_cfg_converter is None:
             if symbol not in self._inverse_stack_symbol_d:
@@ -48,9 +48,9 @@ def _get_symbol_index(self, symbol: CFGConvertible) -> int:
         return symbol.index_cfg_converter
 
     def to_cfg_combined_variable(self,
-                                 state0: CFGConvertible,
-                                 stack_symbol: CFGConvertible,
-                                 state1: CFGConvertible) -> Variable:
+                                 state0: CFGObjectConvertible,
+                                 stack_symbol: CFGObjectConvertible,
+                                 state1: CFGObjectConvertible) -> Variable:
         """ Conversion used in the to_pda method """
         i_stack_symbol, i_state0, i_state1 = self._get_indexes(
             stack_symbol, state0, state1)
@@ -74,19 +74,19 @@ def _create_new_variable(self,
         return temp
 
     def set_valid(self,
-                  state0: CFGConvertible,
-                  stack_symbol: CFGConvertible,
-                  state1: CFGConvertible) -> None:
+                  state0: CFGObjectConvertible,
+                  stack_symbol: CFGObjectConvertible,
+                  state1: CFGObjectConvertible) -> None:
         """Set valid"""
         i_stack_symbol, i_state0, i_state1 = self._get_indexes(
             stack_symbol, state0, state1)
         prev = self._conversions[i_state0][i_stack_symbol][i_state1]
         self._conversions[i_state0][i_stack_symbol][i_state1] = (True, prev[1])
 
     def is_valid_and_get(self,
-                         state0: CFGConvertible,
-                         stack_symbol: CFGConvertible,
-                         state1: CFGConvertible) -> Optional[Variable]:
+                         state0: CFGObjectConvertible,
+                         stack_symbol: CFGObjectConvertible,
+                         state1: CFGObjectConvertible) -> Optional[Variable]:
         """Check if valid and get"""
         i_state0 = self._get_state_index(state0)
         i_stack_symbol = self._get_symbol_index(stack_symbol)
@@ -102,9 +102,9 @@ def is_valid_and_get(self,
         return current[1]
 
     def _get_indexes(self,
-                     stack_symbol: CFGConvertible,
-                     state0: CFGConvertible,
-                     state1: CFGConvertible) \
+                     stack_symbol: CFGObjectConvertible,
+                     state0: CFGObjectConvertible,
+                     state1: CFGObjectConvertible) \
             -> Tuple[int, int, int]:
         i_state0 = self._get_state_index(state0)
         i_stack_symbol = self._get_symbol_index(stack_symbol)

pyformlang/cfg/formal_grammar.py

@@ -67,11 +67,21 @@ def start_symbol(self) -> Optional[Variable]:
         """
         return self._start_symbol
 
-    @start_symbol.setter
-    def start_symbol(self, symbol: Hashable) -> None:
-        """ Sets the start symbol of the grammar """
-        self._start_symbol = to_variable(symbol) \
-            if symbol is not None else None
+    def add_production(self, production: Production) -> None:
+        """ Adds the given production to the grammar """
+        self.variables.update(production.variables)
+        self.terminals.update(production.terminals)
+        self.productions.add(production)
+
+    def add_start_symbol(self, symbol: Hashable) -> None:
+        """ Adds the start symbol to the grammar """
+        symbol = to_variable(symbol)
+        self.variables.add(symbol)
+        self._start_symbol = symbol
+
+    def remove_start_symbol(self) -> None:
+        """ Removes the start symbol from the grammar """
+        self._start_symbol = None
 
     @abstractmethod
     def copy(self: GrammarT) -> GrammarT:

pyformlang/cfg/tests/test_cfg.py

@@ -847,6 +847,31 @@ def test_copy(self):
         assert cfg.start_symbol == cfg_copy.start_symbol
         assert cfg is not cfg_copy
 
+    def test_add_production(self):
+        text_example = get_example_text_duplicate()
+        cfg = CFG.from_text(text_example)
+        assert Epsilon() not in cfg.terminals
+        production = Production(Variable("K"),
+                                [Epsilon(), Terminal("a"), Variable("B")])
+        cfg.add_production(production)
+        assert production in cfg.productions
+        assert "K" in cfg.variables
+        assert "a" in cfg.terminals
+        assert "B" in cfg.variables
+        assert Epsilon() not in cfg.terminals
+
+    def test_start_symbol(self):
+        cfg = CFG()
+        assert not cfg.variables
+        assert not cfg.start_symbol
+        cfg.add_start_symbol("S")
+        assert cfg.start_symbol == "S"
+        assert "S" in cfg.variables
+        cfg.remove_start_symbol()
+        assert not cfg.start_symbol
+        cfg.remove_start_symbol()
+        assert not cfg.start_symbol
+
 
 def get_example_text_duplicate():
     """ Duplicate text """

pyformlang/finite_automaton/finite_automaton.py

@@ -40,6 +40,7 @@ class FiniteAutomaton(Iterable[Tuple[State, Symbol, State]]):
         A set of final or accepting states. It is a subset of states.
     """
 
+    @abstractmethod
     def __init__(self) -> None:
         self._states: Set[State]
         self._input_symbols: Set[Symbol]

pyformlang/finite_automaton/tests/test_epsilon.py

@@ -3,7 +3,7 @@
 """
 
 from pyformlang.finite_automaton import Epsilon
-from pyformlang.finite_automaton import Symbol
+from pyformlang.finite_automaton import State, Symbol
 
 
 class TestEpsilon:
@@ -18,3 +18,5 @@ def test_epsilon(self):
         assert eps0 != symb
         assert "epsilon" == Epsilon()
         assert Epsilon() == "ɛ"
+        assert Symbol("ɛ") != Epsilon()
+        assert Epsilon() != State("epsilon")

pyformlang/objects/base_epsilon.py

@@ -21,7 +21,8 @@ def __init__(self) -> None:
         super().__init__("epsilon")
 
     def __eq__(self, other: Any) -> bool:
-        return isinstance(other, BaseEpsilon) or other in EPSILON_SYMBOLS
+        return isinstance(other, BaseEpsilon) \
+            or not isinstance(other, FormalObject) and other in EPSILON_SYMBOLS
 
     def __hash__(self) -> int:
         return super().__hash__()

pyformlang/objects/cfg_objects/__init__.py

@@ -5,12 +5,12 @@
 from .terminal import Terminal
 from .epsilon import Epsilon
 from .production import Production
-from .cfg_convertible import CFGConvertible
+from .cfg_object_convertible import CFGObjectConvertible
 
 
 __all__ = ["CFGObject",
            "Variable",
            "Terminal",
            "Epsilon",
            "Production",
-           "CFGConvertible"]
+           "CFGObjectConvertible"]

pyformlang/objects/cfg_objects/cfg_object.py

@@ -2,11 +2,10 @@
 
 from abc import abstractmethod
 
-from .cfg_convertible import CFGConvertible
-from ..formal_object import FormalObject
+from .cfg_object_convertible import CFGObjectConvertible
 
 
-class CFGObject(CFGConvertible, FormalObject):
+class CFGObject(CFGObjectConvertible):
     """ An object in a CFG
 
     Parameters

pyformlang/objects/cfg_objects/cfg_convertible.py renamed to pyformlang/objects/cfg_objects/cfg_object_convertible.py

@@ -1,11 +1,18 @@
 """ Interface representing the ability of conversion to cfg object """
 
 from typing import Optional, Any
+from abc import abstractmethod
 
+from ..formal_object import FormalObject
 
-class CFGConvertible:
+
+class CFGObjectConvertible(FormalObject):
     """ Interface representing the ability of conversion to cfg object """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self.index_cfg_converter: Optional[int] = None
+
+    @abstractmethod
+    def __repr__(self) -> str:
+        raise NotImplementedError