Add pipeline states to ir (#499)

* Add pipeline states to ir

* Add doc for ir

* Restructure IR

* Update IR parse

* Update selector serialization

* Add informative error message

* init implement of Selector serialization/deserialization

* passed given unit tests

* Selector inherits Configurable and assures backward compatability

* Fix pylint err

* resolved PR comments on Selector 1.0

* Fix lint issue

* pipeline calls selectors'  method

* removed is_initialized property from Selector

* implemented Selector initialize method

* Fix black issue

* Ignore too-many-public-methods pylint error

* Fix mypy error

* Fix black issue

Co-authored-by: Suqi Sun <suqi.sun@petuum.com>
Co-authored-by: Zhanyuan Zhang <zhanyuan.zhang@petuum.com>
Co-authored-by: Hector <hunterhector@gmail.com>

Author: 4 people

forte/data/ontology/code_generation_objects.py

@@ -785,6 +785,54 @@ def collect_parents(self, node_dict: Dict[str, Set[str]]):
                     ] = found_node.parent.attributes
                     found_node = found_node.parent
 
+    def todict(self) -> Dict[str, Any]:
+        r"""Dump the EntryTree structure to a dictionary.
+
+        Returns:
+            dict: A dictionary storing the EntryTree.
+        """
+
+        def node_to_dict(node: EntryTreeNode):
+            return (
+                None
+                if not node
+                else {
+                    "name": node.name,
+                    "attributes": list(node.attributes),
+                    "children": [
+                        node_to_dict(child) for child in node.children
+                    ],
+                }
+            )
+
+        return node_to_dict(self.root)
+
+    def fromdict(
+        self, tree_dict: Dict[str, Any], parent_entry_name: Optional[str] = None
+    ) -> Optional["EntryTree"]:
+        r"""Load the EntryTree structure from a dictionary.
+
+        Args:
+            tree_dict: A dictionary storing the EntryTree.
+            parent_entry_name: The type name of the parent of the node to be
+                built. Default value is None.
+        """
+        if not tree_dict:
+            return None
+
+        if parent_entry_name is None:
+            self.root = EntryTreeNode(name=tree_dict["name"])
+            self.root.attributes = set(tree_dict["attributes"])
+        else:
+            self.add_node(
+                curr_entry_name=tree_dict["name"],
+                parent_entry_name=parent_entry_name,
+                curr_entry_attr=set(tree_dict["attributes"]),
+            )
+        for child in tree_dict["children"]:
+            self.fromdict(child, tree_dict["name"])
+        return self
+
 
 def search(node: EntryTreeNode, search_node_name: str):
     if node.name == search_node_name:

forte/data/selector.py

@@ -15,10 +15,12 @@
 This defines some selector interface used as glue to combine
 DataPack/multiPack processors and Pipeline.
 """
-from typing import Generic, Iterator, TypeVar
+from typing import Generic, Iterator, TypeVar, Optional, Union, Dict, Any
 
 import re
 
+from forte.common.configuration import Config
+from forte.common.configurable import Configurable
 from forte.data.base_pack import BasePack
 from forte.data.data_pack import DataPack
 from forte.data.multi_pack import MultiPack
@@ -37,13 +39,18 @@
 ]
 
 
-class Selector(Generic[InputPackType, OutputPackType]):
-    def __init__(self, **kwargs):
-        pass
+class Selector(Generic[InputPackType, OutputPackType], Configurable):
+    def __init__(self):
+        self.configs: Config = Config({}, {})
 
     def select(self, pack: InputPackType) -> Iterator[OutputPackType]:
         raise NotImplementedError
 
+    def initialize(
+        self, configs: Optional[Union[Config, Dict[str, Any]]] = None
+    ):
+        self.configs = self.make_configs(configs)
+
 
 class DummySelector(Selector[InputPackType, InputPackType]):
     r"""Do nothing, return the data pack itself, which can be either
@@ -66,12 +73,23 @@ def select(self, pack: MultiPack) -> Iterator[DataPack]:
 class NameMatchSelector(SinglePackSelector):
     r"""Select a :class:`DataPack` from a :class:`MultiPack` with specified
     name.
+
+    This implementation takes special care for backward compatability:
+    Deprecated:
+        selector = NameMatchSelector(select_name="foo")
+        selector = NameMatchSelector("foo")
+    Now:
+        selector = NameMatchSelector()
+        selector.initialize(
+            configs={
+                "select_name": "foo"
+            }
+        )
     """
 
-    def __init__(self, select_name: str):
+    def __init__(self, select_name: Optional[str] = None):
         super().__init__()
-        assert select_name is not None
-        self.select_name: str = select_name
+        self.select_name = select_name
 
     def select(self, m_pack: MultiPack) -> Iterator[DataPack]:
         matches = 0
@@ -85,23 +103,67 @@ def select(self, m_pack: MultiPack) -> Iterator[DataPack]:
                 f"Pack name {self.select_name}" f" not in the MultiPack"
             )
 
+    def initialize(
+        self, configs: Optional[Union[Config, Dict[str, Any]]] = None
+    ):
+        if self.select_name is not None:
+            super().initialize({"select_name": self.select_name})
+        else:
+            super().initialize(configs)
+
+        if self.configs["select_name"] is None:
+            raise ValueError("select_name shouldn't be None.")
+        self.select_name = self.configs["select_name"]
+
+    @classmethod
+    def default_configs(cls):
+        return {"select_name": None}
+
 
 class RegexNameMatchSelector(SinglePackSelector):
-    r"""Select a :class:`DataPack` from a :class:`MultiPack` using a regex."""
+    r"""Select a :class:`DataPack` from a :class:`MultiPack` using a regex.
+
+    This implementation takes special care for backward compatability:
+    Deprecated:
+        selector = RegexNameMatchSelector(select_name="^.*\\d$")
+        selector = RegexNameMatchSelector("^.*\\d$")
+    Now:
+        selector = RegexNameMatchSelector()
+        selector.initialize(
+            configs={
+                "select_name": "^.*\\d$"
+            }
+        )
+    """
 
-    def __init__(self, select_name: str):
+    def __init__(self, select_name: Optional[str] = None):
         super().__init__()
-        assert select_name is not None
-        self.select_name: str = select_name
+        self.select_name = select_name
 
     def select(self, m_pack: MultiPack) -> Iterator[DataPack]:
         if len(m_pack.packs) == 0:
             raise ValueError("Multi-pack is empty")
         else:
             for name, pack in m_pack.iter_packs():
-                if re.match(self.select_name, name):
+                if re.match(self.select_name, name):  # type: ignore
                     yield pack
 
+    def initialize(
+        self, configs: Optional[Union[Config, Dict[str, Any]]] = None
+    ):
+        if self.select_name is not None:
+            super().initialize({"select_name": self.select_name})
+        else:
+            super().initialize(configs)
+
+        if self.configs["select_name"] is None:
+            raise ValueError("select_name shouldn't be None.")
+        self.select_name = self.configs["select_name"]
+
+    @classmethod
+    def default_configs(cls):
+        return {"select_name": None}
+
 
 class FirstPackSelector(SinglePackSelector):
     r"""Select the first entry from :class:`MultiPack` and yield it."""