Repository: skit-ai/dialogy (language: python)

Issue:
Time entities should allow filtering past dates or future dates
**Is your feature request related to a problem? Please describe.**
Sentences like "मुझे परसो शाम 5 बजे कॉल करना"
परसो - points to a day before and a day after both.

This produces time entities like so:
```
{'entities': [{'alternative_index': None,
               'body': 'परसो शाम 5 बजे',
               'dim': 'time',
               'entity_type': 'datetime',
               'grain': 'hour',
               'latent': False,
               'origin': 'value',
               'parsers': [],
               'range': {'end': 23, 'start': 9},
               'score': None,
               'slot_names': [],
               'type': 'datetime',
               'value': '2021-05-31T17:00:00.000+05:30',
               'values': [{'grain': 'hour',
                           'type': 'value',
                           'value': '2021-05-31T17:00:00.000+05:30'}]},
              {'alternative_index': None,
               'body': 'परसो शाम 5 बजे',
               'dim': 'time',
               'entity_type': 'datetime',
               'grain': 'hour',
               'latent': False,
               'origin': 'value',
               'parsers': [],
               'range': {'end': 23, 'start': 9},
               'score': None,
               'slot_names': [],
               'type': 'datetime',
               'value': '2021-06-04T17:00:00.000+05:30',
               'values': [{'grain': 'hour',
                           'type': 'value',
                           'value': '2021-06-04T17:00:00.000+05:30'}]}],
 'version': '0.1.0'}
```
There is no utility to sort/filter these, I mostly want to use the future values here.

**Describe the solution you'd like**
I wish to get the oldest or the latest value here.

**Describe alternatives you've considered**
Writing a plugin to do this but feels like a lot of code to write for a simple comparison check that could happen here.


Discussion / hints:
`DucklingPlugin` should take a `kwarg` for providing only future dates or only past dates.

Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6ae90ca3..9ab78365 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+# Unreleased -- 0.6.1
+- [ ] feat: future or past datetime only support from `DucklingPlugin`.
+
 # 0.6.0
 
 - [x] feat: spacy, pattern entity parsing from list support.
diff --git a/dialogy/preprocess/text/duckling_plugin.py b/dialogy/preprocess/text/duckling_plugin.py
index 84c8e023..a986f31b 100644
--- a/dialogy/preprocess/text/duckling_plugin.py
+++ b/dialogy/preprocess/text/duckling_plugin.py
@@ -47,6 +47,8 @@ def update_workflow(workflow, entities):
 
 """
 import json
+import operator
+import traceback
 from pprint import pformat
 from typing import Any, Dict, List, Optional
 
@@ -54,6 +56,7 @@ def update_workflow(workflow, entities):
 import requests
 from pytz.tzinfo import BaseTzInfo  # type: ignore
 
+from dialogy import constants as const
 from dialogy.constants import EntityKeys
 from dialogy.plugin import Plugin, PluginFn
 from dialogy.types.entity import BaseEntity, dimension_entity_map
@@ -104,6 +107,10 @@ class DucklingPlugin(Plugin):
     :type url: Optional[str]
     """
 
+    FUTURE = "future"
+    PAST = "past"
+    DATETIME_OPERATION_ALIAS = {FUTURE: operator.ge, PAST: operator.le}
+
     def __init__(
         self,
         dimensions: List[str],
@@ -111,6 +118,7 @@ def __init__(
         timeout: float = 0.5,
         url: str = "http://0.0.0.0:8000/parse",
         locale: str = "en_IN",
+        datetime_filters: Optional[str] = None,
         access: Optional[PluginFn] = None,
         mutate: Optional[PluginFn] = None,
         entity_map: Optional[Dict[str, Any]] = None,
@@ -125,6 +133,8 @@ def __init__(
         self.timezone = timezone
         self.timeout = timeout
         self.url = url
+        self.reference_time = None
+        self.datetime_filters = datetime_filters
         self.headers: Dict[str, str] = {
             "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
         }
@@ -191,6 +201,7 @@ def __create_req_body(
 
         return payload
 
+    @dbg(log)
     def _reshape(self, entities_json: List[Dict[str, Any]]) -> List[BaseEntity]:
         """
         Create a list of :ref:`BaseEntity <base_entity>` objects from a list of entity dicts.
@@ -236,6 +247,7 @@ def _reshape(self, entities_json: List[Dict[str, Any]]) -> List[BaseEntity]:
         except KeyError as key_error:
             # Being vary of structural changes in the API or entity dicts.
             # Under normal circumstances this error shouldn't be raised.
+            log.debug(traceback.format_exc())
             raise KeyError(
                 f"Missing key {key_error} in entity {entity}."
             ) from key_error
@@ -276,10 +288,78 @@ def _get_entities(
             f"Duckling API call failed | [{response.status_code}]: {response.text}"
         )
 
+    @dbg(log)
+    def select_datetime(
+        self, entities: List[BaseEntity], filter_type: Any
+    ) -> List[BaseEntity]:
+        """
+        Select datetime entities as per the filters provided in the configuration.
+
+        :param entities: A list of entities.
+        :type entities: List[BaseEntity]
+        :param filter_type:
+        :type filter_type: str
+        :return: List of entities obtained after applying comparator functions.
+        :rtype: List[BaseEntity]
+        """
+        if not isinstance(filter_type, str):
+            raise TypeError(
+                f"Expected datetime_filters to be a str and one of {self.FUTURE}, {self.PAST} or"
+                " a valid comparison operator here: https://docs.python.org/3/library/operator.html"
+            )
+
+        if filter_type in self.DATETIME_OPERATION_ALIAS:
+            operation = self.DATETIME_OPERATION_ALIAS[filter_type]
+        else:
+            try:
+                operation = getattr(operator, filter_type)
+            except (AttributeError, TypeError):
+                log.debug(traceback.format_exc())
+                raise ValueError(
+                    f"Expected datetime_filters to be one of {self.FUTURE}, {self.PAST} "
+                    "or a valid comparison operator here: https://docs.python.org/3/library/operator.html"
+                )
+
+        return [
+            entity
+            for entity in entities
+            if entity.dim == const.TIME
+            and operation(entity.get_value(), self.reference_time)
+        ]
+
+    def apply_filters(self, entities: List[BaseEntity]) -> List[BaseEntity]:
+        """
+        Filter entities by configurable criteria.
+
+        The utility of this method is tracked here:
+        https://github.com/Vernacular-ai/dialogy/issues/42
+
+        We needed a way to express, not all datetime entities are needed. There are needs which can be
+        expressed as filters: want greater or lesser than the reference time, etc. There are more applications
+        where we expect sorting, filtering by other attributes as well. This method is an advent of such expressions.
+
+        :param entities: A list of entities.
+        :type entities: List[BaseEntity]
+        :return: A list of entities obtained after applying filters.
+        :rtype: List[BaseEntity]
+        """
+        if self.datetime_filters is None:
+            return entities
+
+        return self.select_datetime(entities, self.datetime_filters)
+
     def utility(self, *args: Any) -> List[BaseEntity]:
+        """
+        Produces Duckling entities, runs with a :ref:`Workflow's run<workflow_run>` method.
+
+        :param args: Expects a tuple of :code:`Tuple[natural language for parsing entities, reference time in seconds, locale]`
+        :type args: Tuple(str, int, str)
+        :return: A list of duckling entities.
+        :rtype: List[BaseEntity]
+        """
         entities = []
         input_, reference_time, locale = args
-
+        self.reference_time = reference_time
         try:
             if isinstance(input_, str):
                 entities.append(
@@ -299,6 +379,7 @@ def utility(self, *args: Any) -> List[BaseEntity]:
                 entity for entity_list in entities for entity in entity_list
             ]
             shaped_entities = self._reshape(entities_flattened)
-            return shaped_entities
+            filtered_entities = self.apply_filters(shaped_entities)
+            return filtered_entities
         except ValueError as value_error:
             raise ValueError(str(value_error)) from value_error
diff --git a/dialogy/types/entity/base_entity.py b/dialogy/types/entity/base_entity.py
index b6e22129..2383ba19 100644
--- a/dialogy/types/entity/base_entity.py
+++ b/dialogy/types/entity/base_entity.py
@@ -181,7 +181,7 @@ def add_parser(self, postprocessor: PluginFn) -> None:
         """
         self.parsers.append(postprocessor.__name__)
 
-    def get_value(self) -> Any:
+    def get_value(self, *args: Any) -> Any:
         """
         Get value of an entity.
 
@@ -194,16 +194,14 @@ def get_value(self) -> Any:
             IndexError: If `values` is not a `list`.
             KeyError: If each element in `values` is not a `dict`.
         """
+        key = "value"
+        error_message = f'entity value should be in values[0]["{key}"]'
         try:
-            return self.values[0]["value"]
+            return self.values[0][key]
         except IndexError as index_error:
-            raise IndexError(
-                'entity value should be in values[0]["value"]'
-            ) from index_error
+            raise IndexError(error_message) from index_error
         except KeyError as key_error:
-            raise KeyError(
-                'entity value should be in values[0]["value"]'
-            ) from key_error
+            raise KeyError(error_message) from key_error
 
     def copy(self) -> "BaseEntity":
         """
diff --git a/dialogy/types/entity/time_entity.py b/dialogy/types/entity/time_entity.py
index 0f51eab5..7cfdf0ce 100644
--- a/dialogy/types/entity/time_entity.py
+++ b/dialogy/types/entity/time_entity.py
@@ -47,7 +47,7 @@ def reshape(cls, dict_: Dict[str, Any]) -> Dict[str, Any]:
             ]
         return dict_
 
-    def get_date_value(self, date: Dict[str, str]) -> Optional[str]:
+    def get_value(self, date: Optional[Dict[str, str]] = None) -> Optional[datetime]:  # type: ignore # pylint: disable=arguments-differ
         """
         Return the date string in ISO format from the dictionary passed
 
@@ -62,10 +62,13 @@ def get_date_value(self, date: Dict[str, str]) -> Optional[str]:
         :param date: Dictionary which stores the datetime in ISO format, grain and type
         :type date: Dict[str, str]
         :return: :code:`date["value"]`
-        :rtype: Optional[str]
+        :rtype: Optional[datetime]
         """
-        if date.get("value"):
-            return date["value"]
+        entity_date_value = (
+            super(TimeEntity, self).get_value() if not date else date.get("value")
+        )
+        if entity_date_value:
+            return datetime.fromisoformat(entity_date_value)
         else:
             raise KeyError(f"Expected key `value` in {date} for {self}")
 
@@ -117,9 +120,9 @@ def is_uniq_date_from_values(self) -> bool:
         """
         dates = []
         for date_value in self.values:
-            date_ = self.get_date_value(date_value)
+            date_ = self.get_value(date_value)
             if date_:
-                dates.append(datetime.fromisoformat(date_).day)
+                dates.append(date_.day)
         return len(py_.uniq(dates)) == 1
 
     def is_uniq_day_from_values(self) -> bool:
@@ -134,9 +137,9 @@ def is_uniq_day_from_values(self) -> bool:
         """
         dates = []
         for date_value in self.values:
-            date_ = self.get_date_value(date_value)
+            date_ = self.get_value(date_value)
             if date_:
-                dates.append(datetime.fromisoformat(date_))
+                dates.append(date_)
         # Duckling may return 3 datetime values in chronological order.
         # For cases where someone has said "Monday", we will get 3 values,
         # each value a week apart.
diff --git a/dialogy/types/entity/time_interval_entity.py b/dialogy/types/entity/time_interval_entity.py
index 6fa4e685..7da750fb 100644
--- a/dialogy/types/entity/time_interval_entity.py
+++ b/dialogy/types/entity/time_interval_entity.py
@@ -5,6 +5,7 @@
 Import classes:
     - TimeIntervalEntity
 """
+from datetime import datetime
 from typing import Any, Dict, Optional
 
 import attr
@@ -45,7 +46,7 @@ def reshape(cls, dict_: Dict[str, Any]) -> Dict[str, Any]:
             dict_[const.EntityKeys.GRAIN] = date_range[const.EntityKeys.GRAIN]
         return dict_
 
-    def get_date_value(self, date: Dict[str, Any]) -> Optional[str]:
+    def get_value(self, date: Optional[Dict[str, Any]] = None) -> Optional[datetime]:  # type: ignore # pylint: disable=arguments-differ
         """
         Return the date string in ISO format from the dictionary passed
 
@@ -62,11 +63,15 @@ def get_date_value(self, date: Dict[str, Any]) -> Optional[str]:
         :param date: Dictionary which stores the datetime in ISO format, grain and type
         :type date: Dict[str, str]
         :return: :code:`date["value"]`
-        :rtype: Optional[str]
+        :rtype: Optional[datetime]
         """
-        date_dict = date.get(const.EntityKeys.FROM) or date.get(const.EntityKeys.TO)
+        if not date:
+            date_dict = self.value[const.EntityKeys.FROM or const.EntityKeys.TO]
+        else:
+            date_dict = date.get(const.EntityKeys.FROM) or date.get(const.EntityKeys.TO)
+
         if date_dict:
-            return date_dict.get(const.EntityKeys.VALUE)
+            return datetime.fromisoformat(date_dict.get(const.EntityKeys.VALUE))
         else:
             raise KeyError(
                 f"Expected at least 1 of `from` or `to` in {self.values} for {self}"
diff --git a/dialogy/workflow/workflow.py b/dialogy/workflow/workflow.py
index 70ee0251..c00f0c4f 100644
--- a/dialogy/workflow/workflow.py
+++ b/dialogy/workflow/workflow.py
@@ -192,6 +192,8 @@ def inference(self) -> None:
 
     def run(self, input_: Any) -> Any:
         """
+        .. _workflow_run:
+
         Get final results from the workflow.
 
         The current workflow exhibits the following simple procedure:
diff --git a/docs/_modules/dialogy/constants.html b/docs/_modules/dialogy/constants.html
index 5d7f13cb..baaacf32 100644
--- a/docs/_modules/dialogy/constants.html
+++ b/docs/_modules/dialogy/constants.html
@@ -211,6 +211,7 @@ <h1>Source code for dialogy.constants</h1><div class="highlight"><pre>
     <span class="n">FROM</span> <span class="o">=</span> <span class="s2">"from"</span>
     <span class="n">GRAIN</span> <span class="o">=</span> <span class="s2">"grain"</span>
     <span class="n">INTERVAL</span> <span class="o">=</span> <span class="s2">"interval"</span>
+    <span class="n">DURATION</span> <span class="o">=</span> <span class="s2">"duration"</span>
     <span class="n">LATENT</span> <span class="o">=</span> <span class="s2">"latent"</span>
     <span class="n">RANGE</span> <span class="o">=</span> <span class="s2">"range"</span>
     <span class="n">START</span> <span class="o">=</span> <span class="s2">"start"</span>
@@ -252,11 +253,26 @@ <h1>Source code for dialogy.constants</h1><div class="highlight"><pre>
 <span class="n">TIME_ENTITY_PROPS</span> <span class="o">=</span> <span class="n">BASE_ENTITY_PROPS</span> <span class="o">+</span> <span class="p">[([</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">GRAIN</span><span class="p">],</span> <span class="nb">str</span><span class="p">)]</span>
 <span class="n">PEOPLE_ENTITY_PROPS</span> <span class="o">=</span> <span class="n">BASE_ENTITY_PROPS</span> <span class="o">+</span> <span class="p">[([</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">UNIT</span><span class="p">],</span> <span class="nb">str</span><span class="p">)]</span>
 
+<span class="c1"># Time related constants</span>
+<span class="n">DATE_UNITS</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"day"</span><span class="p">,</span> <span class="s2">"week"</span><span class="p">,</span> <span class="s2">"month"</span><span class="p">,</span> <span class="s2">"quarter"</span><span class="p">,</span> <span class="s2">"year"</span><span class="p">]</span>
+<span class="n">TIME_UNITS</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"hour"</span><span class="p">,</span> <span class="s2">"minute"</span><span class="p">,</span> <span class="s2">"second"</span><span class="p">]</span>
+
+<span class="c1"># Time Entity types</span>
+<span class="n">DATE</span> <span class="o">=</span> <span class="s2">"date"</span>
+<span class="n">TIME</span> <span class="o">=</span> <span class="s2">"time"</span>
+<span class="n">DATETIME</span> <span class="o">=</span> <span class="s2">"datetime"</span>
+
+
 <span class="c1"># This section covers signals tuple indices</span>
 <div class="viewcode-block" id="SIGNAL"><a class="viewcode-back" href="../../source/dialogy.constants.html#dialogy.constants.SIGNAL">[docs]</a><span class="k">class</span> <span class="nc">SIGNAL</span><span class="p">:</span>
     <span class="n">NAME</span> <span class="o">=</span> <span class="mi">0</span>
     <span class="n">STRENGTH</span> <span class="o">=</span> <span class="mi">1</span>
     <span class="n">REPRESENTATION</span> <span class="o">=</span> <span class="mi">2</span></div>
+
+
+<span class="n">KEYWORD</span> <span class="o">=</span> <span class="s2">"keyword"</span>
+<span class="n">REGEX</span> <span class="o">=</span> <span class="s2">"regex"</span>
+<span class="n">SPACY</span> <span class="o">=</span> <span class="s2">"spacy"</span>
 </pre></div>
       </article>
       <footer>
diff --git a/docs/_modules/dialogy/plugin/plugin.html b/docs/_modules/dialogy/plugin/plugin.html
index d085e366..25be79a2 100644
--- a/docs/_modules/dialogy/plugin/plugin.html
+++ b/docs/_modules/dialogy/plugin/plugin.html
@@ -183,60 +183,119 @@
           <i class="icon"><svg><use href="#svg-toc"></use></svg></i>
         </label>
         <h1>Source code for dialogy.plugin.plugin</h1><div class="highlight"><pre>
-<span></span><span class="sd">"""Module provides access to an abstract plugin class.</span>
+<span></span>"""
+.. _plugin:
 
-<span class="sd">## Tutorials</span>
+Module provides access to an abstract plugin class.
 
-<span class="sd">- [MakePlugins](../../tests/plugin/test_plugins.html)</span>
-<span class="sd">- [DucklingParser](../../tests/parser/text/entity/test_duckling_parser.html)</span>
-<span class="sd">- [RuleSlotFiller](../../tests/postprocess/text/slot_filler/test_rule_slot_filler.html)</span>
+We will summarize a few key points for creating plugins:
 
-<span class="sd">## Summary</span>
+-   Don't interact with the workflow directly, use functions to access and mutate.
+-   The convention for workflow access is `access(workflow)`.
+-   The convention for workflow modification is `mutate(workflow, value)`.
+-   Plugin names must end with Plugin for classes and _plugin for functions.
 
-<span class="sd">We will summarize a few key points for creating plugins:</span>
+examples:
+- Sentence2VecPlugin
+- words2num_plugin
+- RuleSlotFilerPlugin
+- VotePlugin
+"""
+from typing import Any, Optional
 
-<span class="sd">-   Don't interact with the workflow directly, use functions to access and mutate.</span>
-<span class="sd">-   The convention for workflow access is `access(workflow)`.</span>
-<span class="sd">-   The convention for workflow modification is `mutate(workflow, value)`.</span>
-<span class="sd">-   **Plugin names must end with Plugin for classes and _plugin for functions.** examples: `Sentence2VecPlugin`, `words2num_plugin`.</span>
+from dialogy.types.plugin import PluginFn
+from dialogy.workflow import Workflow
 
-<span class="sd">Import classes:</span>
-<span class="sd">    - Plugin</span>
-<span class="sd">"""</span>
-<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Optional</span>
 
-<span class="kn">import</span> <span class="nn">attr</span>
+<div class="viewcode-block" id="Plugin"><a class="viewcode-back" href="../../../source/dialogy.plugin.html#dialogy.plugin.plugin.Plugin">[docs]</a>class Plugin:
+    """
+    A :ref:`Plugin &lt;plugin&gt;` instance interacts with a :ref:`workflow&lt;workflow&gt;`. A :ref:`workflow&lt;workflow&gt;` expects
+    a set of plugins to be inserted into different stages: pre and post processing.
+    A plugin can be conveniently written being unaware of the structure of any :ref:`Workflow &lt;workflow&gt;`
+    by expecting `access` and `mutate` functions.
 
-<span class="kn">from</span> <span class="nn">dialogy.types.plugin</span> <span class="kn">import</span> <span class="n">PluginFn</span>
+    **Dynamic Inputs**
 
+    An :code:`access` method helps a :ref:`Plugin &lt;plugin&gt;` to require dynamic inputs from the :ref:`workflow&lt;workflow&gt;`
+    while a :code:`mutate` method offers a :ref:`Plugin &lt;plugin&gt;` to update the processed output and place them as per
+    expectations of the :ref:`workflow&lt;workflow&gt;` implementer's design.
 
-<span class="c1"># = Plugin =</span>
-<div class="viewcode-block" id="Plugin"><a class="viewcode-back" href="../../../source/dialogy.plugin.html#dialogy.plugin.plugin.Plugin">[docs]</a><span class="nd">@attr</span><span class="o">.</span><span class="n">s</span>
-<span class="k">class</span> <span class="nc">Plugin</span><span class="p">:</span>
-    <span class="sd">"""</span>
-<span class="sd">    A plugin object interacts with a [`workflow`](../workflow/workflow.html). Workflows expect a set of plugins</span>
-<span class="sd">    to be inserted into different stages: pre and post processing. A plugin can be conveniently written being unaware of the</span>
-<span class="sd">    structure of a given [`workflow`](../workflow/workflow.html) by expecting `access` and `mutate` functions.</span>
-<span class="sd">    """</span>
+    **Static Inputs**
 
-    <span class="c1"># An `access` function is defined to safely extract data from a workflow.</span>
-    <span class="n">access</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">]</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+    In case there are static inputs that won't change at runtime, these can be pre-loaded into the
+    :ref:`Plugin &lt;plugin&gt;` by extending it.
 
-    <span class="c1"># A `mutate` function allows inserting/overwriting data into a workflow.</span>
-    <span class="n">mutate</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">]</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+    An example for this is:
 
-    <span class="k">def</span> <span class="fm">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">PluginFn</span><span class="p">:</span>
-        <span class="sd">"""</span>
-<span class="sd">        Build a plugin.</span>
+    .. code-block:: python
+        :linenos:
+        :emphasize-lines: 14, 20
 
-<span class="sd">        This method returns a function. Since any functionality can be built into a plugin by</span>
-<span class="sd">        extending the `Plugin` class but they are expected to work uniformly within a `workflow`,</span>
-<span class="sd">        all plugins must have a standard API. The `__call__` method exists just for this abstraction.</span>
+        class CustomPlugin(Plugin):
+            def __init__(
+                self,
+                access: Optional[PluginFn],
+                mutate: Optional[PluginFn]
+            ) -&gt; None:
+                \"""
+                The `.load_corpus()` method reads some corpus.
+                This is useful since we expect to read this
+                just once and use it throughout the runtime.
+                \"""
+                self.access = access
+                self.mutate = mutate
+                self.corpus = None
+                self.load_corpus()
 
-<span class="sd">        A plugin can be designed to do anything, while the `workflow` will expect all plugins</span>
-<span class="sd">        to have a `__call__()` method.</span>
-<span class="sd">        """</span>
-        <span class="o">...</span></div>
+            def load_corpus(corpus_dir: str, file_path: str) -&gt; None:
+                corpus_file = os.path.join(corpus, file_path)
+                with open(corpus_file, "r") as handle:
+                    self.corpus = handle.read().splitlines()
+
+    We ship a few :ref:`Plugins &lt;plugin&gt;` with Dialogy, namely:
+
+    1. :ref:`DucklingPlugin &lt;duckling_plugin&gt;` (pre-processing)
+    2. :ref:`merge_asr_output_plugin &lt;merge_asr_output_plugin&gt;` (pre-processing)
+    3. :ref:`RuleBasedSlotFillerPlugin &lt;rule_slot_filler&gt;` (post-processing)
+    4. :ref:`VotePlugin &lt;vote_plugin&gt;` (post-processing)
+    """
+
+    def __init__(
+        self,
+        access: Optional[PluginFn],
+        mutate: Optional[PluginFn],
+        debug: bool = False,
+    ) -&gt; None:
+        self.access = access
+        self.mutate = mutate
+        self.debug = debug
+
+<div class="viewcode-block" id="Plugin.utility"><a class="viewcode-back" href="../../../source/dialogy.plugin.html#dialogy.plugin.plugin.Plugin.utility">[docs]</a>    def utility(self, *args: Any) -&gt; Any:
+        ...</div>
+
+<div class="viewcode-block" id="Plugin.plugin"><a class="viewcode-back" href="../../../source/dialogy.plugin.html#dialogy.plugin.plugin.Plugin.plugin">[docs]</a>    def plugin(self, workflow: Workflow) -&gt; None:
+        if self.access:
+            args = self.access(workflow)
+            value = self.utility(*args)
+            if value is not None and self.mutate:
+                self.mutate(workflow, value)
+        else:
+            raise TypeError(
+                "Expected access to be functions" f" but {type(self.access)} was found."
+            )</div>
+
+    def __call__(self) -&gt; PluginFn:
+        """
+        Build a plugin.
+
+        This method returns a function. Since any functionality can be built into a plugin by
+        extending the `Plugin` class but they are expected to work uniformly within a `workflow`,
+        all plugins must have a standard API. The `__call__` method exists just for this abstraction.
+
+        A plugin can be designed to do anything, while the `workflow` will expect all plugins
+        to have a `__call__()` method.
+        """
+        return self.plugin</div>
 </pre></div>
       </article>
       <footer>
diff --git a/docs/_modules/dialogy/postprocess/text/slot_filler/rule_slot_filler.html b/docs/_modules/dialogy/postprocess/text/slot_filler/rule_slot_filler.html
index dd4189b7..8ca07f08 100644
--- a/docs/_modules/dialogy/postprocess/text/slot_filler/rule_slot_filler.html
+++ b/docs/_modules/dialogy/postprocess/text/slot_filler/rule_slot_filler.html
@@ -184,111 +184,154 @@
         </label>
         <h1>Source code for dialogy.postprocess.text.slot_filler.rule_slot_filler</h1><div class="highlight"><pre>
 <span></span><span class="sd">"""</span>
-<span class="sd">Module provides access to a rule-based [SlotFiller](../__init__.html).</span>
+<span class="sd">.. _rule_slot_filler:</span>
 
-<span class="sd">## Tutorials</span>
-<span class="sd">- [RuleSlotFiller](../../../../tests/postprocess/text/slot_filler/test_rule_slot_filler.html)</span>
-
-<span class="sd">Imports:</span>
-
-<span class="sd">- RuleBasedSlotFillerPlugin</span>
+<span class="sd">Module provides access to a rule-based :ref:`slot filler&lt;slot_filler&gt;`.</span>
 <span class="sd">"""</span>
-<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Dict</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">Tuple</span>
-
-<span class="kn">import</span> <span class="nn">attr</span>
+<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Any</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">Optional</span>
 
 <span class="kn">from</span> <span class="nn">dialogy.plugin</span> <span class="kn">import</span> <span class="n">Plugin</span>
 <span class="kn">from</span> <span class="nn">dialogy.types.entity</span> <span class="kn">import</span> <span class="n">BaseEntity</span>
 <span class="kn">from</span> <span class="nn">dialogy.types.intent</span> <span class="kn">import</span> <span class="n">Intent</span>
 <span class="kn">from</span> <span class="nn">dialogy.types.plugin</span> <span class="kn">import</span> <span class="n">PluginFn</span>
 <span class="kn">from</span> <span class="nn">dialogy.types.slots</span> <span class="kn">import</span> <span class="n">Rule</span>
-<span class="kn">from</span> <span class="nn">dialogy.workflow</span> <span class="kn">import</span> <span class="n">Workflow</span>
+<span class="kn">from</span> <span class="nn">dialogy.utils.logger</span> <span class="kn">import</span> <span class="n">dbg</span><span class="p">,</span> <span class="n">log</span>
 
 
-<span class="c1"># == RuleBasedSlotFillerPlugin ==</span>
-<div class="viewcode-block" id="RuleBasedSlotFillerPlugin"><a class="viewcode-back" href="../../../../../source/dialogy.postprocess.text.slot_filler.html#dialogy.postprocess.text.slot_filler.rule_slot_filler.RuleBasedSlotFillerPlugin">[docs]</a><span class="nd">@attr</span><span class="o">.</span><span class="n">s</span>
-<span class="k">class</span> <span class="nc">RuleBasedSlotFillerPlugin</span><span class="p">(</span><span class="n">Plugin</span><span class="p">):</span>
+<div class="viewcode-block" id="RuleBasedSlotFillerPlugin"><a class="viewcode-back" href="../../../../../source/dialogy.postprocess.text.slot_filler.html#dialogy.postprocess.text.slot_filler.rule_slot_filler.RuleBasedSlotFillerPlugin">[docs]</a><span class="k">class</span> <span class="nc">RuleBasedSlotFillerPlugin</span><span class="p">(</span><span class="n">Plugin</span><span class="p">):</span>
     <span class="sd">"""</span>
-<span class="sd">    An instance of this class is used for generating a slot-filler.</span>
+<span class="sd">    A utility :ref:`plugin &lt;plugin&gt;` for</span>
+<span class="sd">    `slot filling &lt;https://nlpprogress.com/english/intent_detection_slot_filling.html&gt;`._</span>
+<span class="sd">    An :ref:`Intent &lt;intent&gt;` may have a few slots that need to be filled.</span>
 
-<span class="sd">    Schema for rules looks like:</span>
-<span class="sd">    ```python</span>
+<span class="sd">    This plugin can assist filling pertaining to certain intent:entity:slot-name association rules.</span>
 
-<span class="sd">    {</span>
-<span class="sd">        "&lt;intent_name&gt;": {</span>
-<span class="sd">            "&lt;slot_name&gt;":"&lt;entity_name&gt;"</span>
-<span class="sd">        }</span>
-<span class="sd">    }</span>
-<span class="sd">    ```</span>
-
-<span class="sd">    Plugin signature:</span>
-
-<span class="sd">    - `access(workflow) -&gt; (Intent, List[BaseEntity])`</span>
-<span class="sd">    - `mutate` not required since the mutation is implied through Intent structure change.</span>
-
-<span class="sd">    Irrespective of the entities that are found, only the listed type in the slot shall be present in `values`.</span>
-<span class="sd">    """</span>
-
-    <span class="c1"># **rules**</span>
-    <span class="c1">#</span>
-    <span class="c1"># A `Dict` where each key is an intent name, and each value is another `Dict`,</span>
-    <span class="c1"># in which, each key is an entity and value contains the `slot_name` and `entity_type.`</span>
-    <span class="c1">#</span>
-    <span class="c1"># example:</span>
-    <span class="c1"># ```</span>
-    <span class="c1"># rules = {"intent": {"slot_name": "entity_type"}}</span>
-    <span class="c1"># ```</span>
-    <span class="n">rules</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">Rule</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="n">attr</span><span class="o">.</span><span class="n">Factory</span><span class="p">(</span><span class="n">Dict</span><span class="p">))</span>
-
-    <span class="c1"># **fill_multiple**</span>
-    <span class="c1"># A boolean value that commands the slot filler to add multiple values of the</span>
-    <span class="c1"># same entity type within a slot.</span>
-    <span class="n">fill_multiple</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="nb">bool</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
-
-    <span class="c1"># == filler ==</span>
-<div class="viewcode-block" id="RuleBasedSlotFillerPlugin.filler"><a class="viewcode-back" href="../../../../../source/dialogy.postprocess.text.slot_filler.html#dialogy.postprocess.text.slot_filler.rule_slot_filler.RuleBasedSlotFillerPlugin.filler">[docs]</a>    <span class="k">def</span> <span class="nf">filler</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">workflow</span><span class="p">:</span> <span class="n">Workflow</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
-        <span class="sd">"""</span>
-<span class="sd">        Update an intent slot with compatible entity.</span>
+<span class="sd">    Schema for rules looks like:</span>
 
-<span class="sd">        - `access(workflow)` should return a tuple. `Intent`, `List[BaseEntity]`.</span>
-<span class="sd">        - Only 1 entity fills the slot type.</span>
+<span class="sd">    .. code-block:: json</span>
 
-<span class="sd">        Args:</span>
-<span class="sd">            workflow (Workflow)</span>
+<span class="sd">        {</span>
+<span class="sd">            "intent_name": {</span>
+<span class="sd">                "slot_name":"entity_type"</span>
+<span class="sd">            }</span>
+<span class="sd">        }</span>
 
-<span class="sd">        Raises:</span>
-<span class="sd">            TypeError: self.access should be a Callable.</span>
-<span class="sd">        """</span>
-        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">access</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
-
-            <span class="k">try</span><span class="p">:</span>
-                <span class="n">intent_and_entities</span><span class="p">:</span> <span class="n">Tuple</span><span class="p">[</span><span class="n">Intent</span><span class="p">,</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">]]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">access</span><span class="p">(</span>
-                    <span class="n">workflow</span>
-                <span class="p">)</span>
-                <span class="n">intent</span><span class="p">,</span> <span class="n">entities</span> <span class="o">=</span> <span class="n">intent_and_entities</span>
-                <span class="n">intent</span><span class="o">.</span><span class="n">apply</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">rules</span><span class="p">)</span>
-
-                <span class="k">for</span> <span class="n">entity</span> <span class="ow">in</span> <span class="n">entities</span><span class="p">:</span>
-                    <span class="n">intent</span><span class="o">.</span><span class="n">fill_slot</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">fill_multiple</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">fill_multiple</span><span class="p">)</span>
-
-                <span class="n">intent</span><span class="o">.</span><span class="n">cleanup</span><span class="p">()</span>
-            <span class="k">except</span> <span class="ne">TypeError</span> <span class="k">as</span> <span class="n">type_error</span><span class="p">:</span>
-                <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span>
-                    <span class="sa">f</span><span class="s2">"`access` passed to </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="si">}</span><span class="s2">"</span>
-                    <span class="sa">f</span><span class="s2">" is not a Callable. Received </span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">access</span><span class="p">)</span><span class="si">}</span><span class="s2"> instead."</span>
-                <span class="p">)</span> <span class="kn">from</span> <span class="nn">type_error</span>
-        <span class="k">else</span><span class="p">:</span>
-            <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span>
-                <span class="sa">f</span><span class="s2">"`access` passed to </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="si">}</span><span class="s2">"</span>
-                <span class="sa">f</span><span class="s2">" is not a Callable. Received </span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">access</span><span class="p">)</span><span class="si">}</span><span class="s2"> instead."</span>
-            <span class="p">)</span></div>
-
-    <span class="c1"># == __call__ ==</span>
-    <span class="k">def</span> <span class="fm">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">PluginFn</span><span class="p">:</span>
+<span class="sd">    This can be represented in a yaml format like so:</span>
+
+<span class="sd">    .. code-block:: yaml</span>
+
+<span class="sd">        slots:</span>
+<span class="sd">            faqs:</span>
+<span class="sd">                action_slot: actions</span>
+<span class="sd">            report:</span>
+<span class="sd">                time_slot:</span>
+<span class="sd">                - time</span>
+<span class="sd">                - number</span>
+
+<span class="sd">    Let's run through a practical example. We will create a workflow and preset the output to have expected intent and</span>
+<span class="sd">    entities.</span>
+
+<span class="sd">    .. ipython:: python</span>
+
+<span class="sd">        import yaml</span>
+<span class="sd">        from pprint import pprint</span>
+<span class="sd">        from dialogy.workflow import Workflow</span>
+<span class="sd">        from dialogy.postprocess.text.slot_filler.rule_slot_filler import RuleBasedSlotFillerPlugin</span>
+<span class="sd">        from dialogy.types.intent import Intent</span>
+<span class="sd">        from dialogy.types.entity import PeopleEntity, NumericalEntity</span>
+
+<span class="sd">        # ---------------------------------------------------------------------------------------------------</span>
+<span class="sd">        # Create rules</span>
+<span class="sd">        rule_string = \"""</span>
+        <span class="n">faqs</span><span class="p">:</span>
+            <span class="n">number_slot</span><span class="p">:</span> <span class="n">number</span>
+        <span class="n">count_people</span><span class="p">:</span>
+            <span class="n">number_slot</span><span class="p">:</span>
+            <span class="o">-</span> <span class="n">people</span>
+            <span class="o">-</span> <span class="n">number</span>
+        \<span class="s2">"""</span>
+<span class="s2">        slot_rules = yaml.safe_load(rule_string)</span>
+<span class="s2">        # ---------------------------------------------------------------------------------------------------</span>
+
+<span class="s2">        # ---------------------------------------------------------------------------------------------------</span>
+<span class="s2">        # Setting up the plugin</span>
+<span class="s2">        slot_filler = RuleBasedSlotFillerPlugin(rules=slot_rules, access=lambda w: w.output, debug=True)()</span>
+<span class="s2">        # ---------------------------------------------------------------------------------------------------</span>
+
+<span class="s2">        # ---------------------------------------------------------------------------------------------------</span>
+<span class="s2">        # Creating synthetic values.</span>
+<span class="s2">        # normally you'd get these by running the workflow with models.</span>
+<span class="s2">        intent = Intent(name="count_people", score=1)</span>
+<span class="s2">        number_entity = NumericalEntity(type="number", range={"start": 0, "end": 7}, body='2 people', latent=False, values=[{"values":2}], dim="number")</span>
+<span class="s2">        people_entity = PeopleEntity(type="people", range={"start": 0, "end": 7}, body='2 people', latent=False, values=[{"values":2}], dim="people")</span>
+<span class="s2">        entities = [people_entity, number_entity]</span>
+<span class="s2">        # ---------------------------------------------------------------------------------------------------</span>
+
+<span class="s2">        # ---------------------------------------------------------------------------------------------------</span>
+<span class="s2">        # setting up the workflow to use slot_filler</span>
+<span class="s2">        workflow = Workflow(preprocessors=[], postprocessors=[slot_filler], debug=True)</span>
+<span class="s2">        # ---------------------------------------------------------------------------------------------------</span>
+
+<span class="s2">        # If you notice the instantiation of RuleBasedSlotFillerPlugin,</span>
+<span class="s2">        # you will notice the `access` method expects a Tuple of two elements.</span>
+<span class="s2">        workflow.output = (intent, entities)</span>
+
+<span class="s2">        workflow.run(input_="2 am")</span>
+
+
+
+<span class="s2">    :param rules: A mapping that defines relationship between an intent, its slots and the entities that fill them.</span>
+<span class="s2">    :type rules: Rule</span>
+<span class="s2">    :param fill_multiple: More than one item be allowed to fill a single slot.</span>
+<span class="s2">    :type fill_multiple: bool</span>
+<span class="s2">    :param access: Signature for workflow access is :code:`access(workflow) -&gt; (Intent, List[BaseEntity])`</span>
+<span class="s2">    :type access: Optional[PluginFn]</span>
+<span class="s2">    :param mutate: Not needed, pass :code:`None`.</span>
+<span class="s2">    :type mutate: Optional[PluginFn]</span>
+
+<span class="s2">    Irrespective of the entities that are found, only the listed type in the slot shall be present in `values`.</span>
+<span class="s2">    """</span>
+
+    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+        <span class="n">rules</span><span class="p">:</span> <span class="n">Rule</span><span class="p">,</span>
+        <span class="n">fill_multiple</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="kc">False</span><span class="p">,</span>
+        <span class="n">access</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
+        <span class="n">mutate</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
+        <span class="n">debug</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="kc">False</span><span class="p">,</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
-<span class="sd">        [callable-plugin](../../../plugin/plugin.html#__call__)</span>
+<span class="sd">        constructor</span>
 <span class="sd">        """</span>
-        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">filler</span></div>
+        <span class="c1"># rules</span>
+        <span class="c1">#</span>
+        <span class="c1"># A `Dict` where each key is an intent name, and each value is another `Dict`,</span>
+        <span class="c1"># in which, each key is an entity and value contains the `slot_name` and `entity_type.`</span>
+        <span class="c1">#</span>
+        <span class="c1"># example:</span>
+        <span class="c1"># ```</span>
+        <span class="c1"># rules = {"intent": {"slot_name": "entity_type"}}</span>
+        <span class="c1"># ```</span>
+        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">(</span><span class="n">access</span><span class="o">=</span><span class="n">access</span><span class="p">,</span> <span class="n">mutate</span><span class="o">=</span><span class="n">mutate</span><span class="p">,</span> <span class="n">debug</span><span class="o">=</span><span class="n">debug</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">rules</span><span class="p">:</span> <span class="n">Rule</span> <span class="o">=</span> <span class="n">rules</span> <span class="ow">or</span> <span class="p">{}</span>
+
+        <span class="c1"># fill_multiple</span>
+        <span class="c1"># A boolean value that commands the slot filler to add multiple values of the</span>
+        <span class="c1"># same entity type within a slot.</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">fill_multiple</span> <span class="o">=</span> <span class="n">fill_multiple</span>
+
+<div class="viewcode-block" id="RuleBasedSlotFillerPlugin.fill"><a class="viewcode-back" href="../../../../../source/dialogy.postprocess.text.slot_filler.html#dialogy.postprocess.text.slot_filler.rule_slot_filler.RuleBasedSlotFillerPlugin.fill">[docs]</a>    <span class="k">def</span> <span class="nf">fill</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">intent</span><span class="p">:</span> <span class="n">Intent</span><span class="p">,</span> <span class="n">entities</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="n">intent</span><span class="o">.</span><span class="n">apply</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">rules</span><span class="p">)</span>
+
+        <span class="k">for</span> <span class="n">entity</span> <span class="ow">in</span> <span class="n">entities</span><span class="p">:</span>
+            <span class="n">intent</span><span class="o">.</span><span class="n">fill_slot</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">fill_multiple</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">fill_multiple</span><span class="p">)</span>
+
+        <span class="n">intent</span><span class="o">.</span><span class="n">cleanup</span><span class="p">()</span>
+        <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"intent after slot-filling: </span><span class="si">%s</span><span class="s2">"</span><span class="p">,</span> <span class="n">intent</span><span class="p">)</span></div>
+
+<div class="viewcode-block" id="RuleBasedSlotFillerPlugin.utility"><a class="viewcode-back" href="../../../../../source/dialogy.postprocess.text.slot_filler.html#dialogy.postprocess.text.slot_filler.rule_slot_filler.RuleBasedSlotFillerPlugin.utility">[docs]</a>    <span class="nd">@dbg</span><span class="p">(</span><span class="n">log</span><span class="p">)</span>
+    <span class="k">def</span> <span class="nf">utility</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">:</span> <span class="n">Any</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">fill</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>  <span class="c1"># pylint: disable=no-value-for-parameter</span></div></div>
 </pre></div>
       </article>
       <footer>
diff --git a/docs/_modules/dialogy/preprocess/text/duckling_plugin.html b/docs/_modules/dialogy/preprocess/text/duckling_plugin.html
index 8f8b595c..e43ca1bf 100644
--- a/docs/_modules/dialogy/preprocess/text/duckling_plugin.html
+++ b/docs/_modules/dialogy/preprocess/text/duckling_plugin.html
@@ -232,6 +232,8 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
 
 <span class="sd">"""</span>
 <span class="kn">import</span> <span class="nn">json</span>
+<span class="kn">import</span> <span class="nn">operator</span>
+<span class="kn">import</span> <span class="nn">traceback</span>
 <span class="kn">from</span> <span class="nn">pprint</span> <span class="kn">import</span> <span class="n">pformat</span>
 <span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Any</span><span class="p">,</span> <span class="n">Dict</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">Optional</span>
 
@@ -239,6 +241,7 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
 <span class="kn">import</span> <span class="nn">requests</span>
 <span class="kn">from</span> <span class="nn">pytz.tzinfo</span> <span class="kn">import</span> <span class="n">BaseTzInfo</span>  <span class="c1"># type: ignore</span>
 
+<span class="kn">from</span> <span class="nn">dialogy</span> <span class="kn">import</span> <span class="n">constants</span> <span class="k">as</span> <span class="n">const</span>
 <span class="kn">from</span> <span class="nn">dialogy.constants</span> <span class="kn">import</span> <span class="n">EntityKeys</span>
 <span class="kn">from</span> <span class="nn">dialogy.plugin</span> <span class="kn">import</span> <span class="n">Plugin</span><span class="p">,</span> <span class="n">PluginFn</span>
 <span class="kn">from</span> <span class="nn">dialogy.types.entity</span> <span class="kn">import</span> <span class="n">BaseEntity</span><span class="p">,</span> <span class="n">dimension_entity_map</span>
@@ -289,6 +292,10 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
 <span class="sd">    :type url: Optional[str]</span>
 <span class="sd">    """</span>
 
+    <span class="n">FUTURE</span> <span class="o">=</span> <span class="s2">"future"</span>
+    <span class="n">PAST</span> <span class="o">=</span> <span class="s2">"past"</span>
+    <span class="n">DATETIME_OPERATION_ALIAS</span> <span class="o">=</span> <span class="p">{</span><span class="n">FUTURE</span><span class="p">:</span> <span class="n">operator</span><span class="o">.</span><span class="n">ge</span><span class="p">,</span> <span class="n">PAST</span><span class="p">:</span> <span class="n">operator</span><span class="o">.</span><span class="n">le</span><span class="p">}</span>
+
     <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span>
         <span class="n">dimensions</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span>
@@ -296,6 +303,7 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
         <span class="n">timeout</span><span class="p">:</span> <span class="nb">float</span> <span class="o">=</span> <span class="mf">0.5</span><span class="p">,</span>
         <span class="n">url</span><span class="p">:</span> <span class="nb">str</span> <span class="o">=</span> <span class="s2">"http://0.0.0.0:8000/parse"</span><span class="p">,</span>
         <span class="n">locale</span><span class="p">:</span> <span class="nb">str</span> <span class="o">=</span> <span class="s2">"en_IN"</span><span class="p">,</span>
+        <span class="n">datetime_filters</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
         <span class="n">access</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
         <span class="n">mutate</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
         <span class="n">entity_map</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
@@ -310,6 +318,8 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
         <span class="bp">self</span><span class="o">.</span><span class="n">timezone</span> <span class="o">=</span> <span class="n">timezone</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">timeout</span> <span class="o">=</span> <span class="n">timeout</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="n">url</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">reference_time</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">datetime_filters</span> <span class="o">=</span> <span class="n">datetime_filters</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">headers</span><span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="p">{</span>
             <span class="s2">"Content-Type"</span><span class="p">:</span> <span class="s2">"application/x-www-form-urlencoded; charset=UTF-8"</span>
         <span class="p">}</span>
@@ -376,6 +386,7 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
 
         <span class="k">return</span> <span class="n">payload</span>
 
+    <span class="nd">@dbg</span><span class="p">(</span><span class="n">log</span><span class="p">)</span>
     <span class="k">def</span> <span class="nf">_reshape</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">entities_json</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]])</span> <span class="o">-&gt;</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">]:</span>
         <span class="sd">"""</span>
 <span class="sd">        Create a list of :ref:`BaseEntity &lt;base_entity&gt;` objects from a list of entity dicts.</span>
@@ -421,6 +432,7 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
         <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">key_error</span><span class="p">:</span>
             <span class="c1"># Being vary of structural changes in the API or entity dicts.</span>
             <span class="c1"># Under normal circumstances this error shouldn't be raised.</span>
+            <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="n">traceback</span><span class="o">.</span><span class="n">format_exc</span><span class="p">())</span>
             <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span>
                 <span class="sa">f</span><span class="s2">"Missing key </span><span class="si">{</span><span class="n">key_error</span><span class="si">}</span><span class="s2"> in entity </span><span class="si">{</span><span class="n">entity</span><span class="si">}</span><span class="s2">."</span>
             <span class="p">)</span> <span class="kn">from</span> <span class="nn">key_error</span>
@@ -461,10 +473,78 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
             <span class="sa">f</span><span class="s2">"Duckling API call failed | [</span><span class="si">{</span><span class="n">response</span><span class="o">.</span><span class="n">status_code</span><span class="si">}</span><span class="s2">]: </span><span class="si">{</span><span class="n">response</span><span class="o">.</span><span class="n">text</span><span class="si">}</span><span class="s2">"</span>
         <span class="p">)</span>
 
+<div class="viewcode-block" id="DucklingPlugin.select_datetime"><a class="viewcode-back" href="../../../../source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.select_datetime">[docs]</a>    <span class="nd">@dbg</span><span class="p">(</span><span class="n">log</span><span class="p">)</span>
+    <span class="k">def</span> <span class="nf">select_datetime</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span> <span class="n">entities</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">],</span> <span class="n">filter_type</span><span class="p">:</span> <span class="n">Any</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">]:</span>
+        <span class="sd">"""</span>
+<span class="sd">        Select datetime entities as per the filters provided in the configuration.</span>
+
+<span class="sd">        :param entities: A list of entities.</span>
+<span class="sd">        :type entities: List[BaseEntity]</span>
+<span class="sd">        :param filter_type:</span>
+<span class="sd">        :type filter_type: str</span>
+<span class="sd">        :return: List of entities obtained after applying comparator functions.</span>
+<span class="sd">        :rtype: List[BaseEntity]</span>
+<span class="sd">        """</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">filter_type</span><span class="p">,</span> <span class="nb">str</span><span class="p">):</span>
+            <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span>
+                <span class="sa">f</span><span class="s2">"Expected datetime_filters to be a str and one of </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">FUTURE</span><span class="si">}</span><span class="s2">, </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">PAST</span><span class="si">}</span><span class="s2"> or"</span>
+                <span class="s2">" a valid comparison operator here: https://docs.python.org/3/library/operator.html"</span>
+            <span class="p">)</span>
+
+        <span class="k">if</span> <span class="n">filter_type</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">DATETIME_OPERATION_ALIAS</span><span class="p">:</span>
+            <span class="n">operation</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">DATETIME_OPERATION_ALIAS</span><span class="p">[</span><span class="n">filter_type</span><span class="p">]</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="k">try</span><span class="p">:</span>
+                <span class="n">operation</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">operator</span><span class="p">,</span> <span class="n">filter_type</span><span class="p">)</span>
+            <span class="k">except</span> <span class="p">(</span><span class="ne">AttributeError</span><span class="p">,</span> <span class="ne">TypeError</span><span class="p">):</span>
+                <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="n">traceback</span><span class="o">.</span><span class="n">format_exc</span><span class="p">())</span>
+                <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
+                    <span class="sa">f</span><span class="s2">"Expected datetime_filters to be one of </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">FUTURE</span><span class="si">}</span><span class="s2">, </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">PAST</span><span class="si">}</span><span class="s2"> "</span>
+                    <span class="s2">"or a valid comparison operator here: https://docs.python.org/3/library/operator.html"</span>
+                <span class="p">)</span>
+
+        <span class="k">return</span> <span class="p">[</span>
+            <span class="n">entity</span>
+            <span class="k">for</span> <span class="n">entity</span> <span class="ow">in</span> <span class="n">entities</span>
+            <span class="k">if</span> <span class="n">entity</span><span class="o">.</span><span class="n">dim</span> <span class="o">==</span> <span class="n">const</span><span class="o">.</span><span class="n">TIME</span>
+            <span class="ow">and</span> <span class="n">operation</span><span class="p">(</span><span class="n">entity</span><span class="o">.</span><span class="n">get_value</span><span class="p">(),</span> <span class="bp">self</span><span class="o">.</span><span class="n">reference_time</span><span class="p">)</span>
+        <span class="p">]</span></div>
+
+<div class="viewcode-block" id="DucklingPlugin.apply_filters"><a class="viewcode-back" href="../../../../source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.apply_filters">[docs]</a>    <span class="k">def</span> <span class="nf">apply_filters</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">entities</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">]:</span>
+        <span class="sd">"""</span>
+<span class="sd">        Filter entities by configurable criteria.</span>
+
+<span class="sd">        The utility of this method is tracked here:</span>
+<span class="sd">        https://github.com/Vernacular-ai/dialogy/issues/42</span>
+
+<span class="sd">        We needed a way to express, not all datetime entities are needed. There are needs which can be</span>
+<span class="sd">        expressed as filters: want greater or lesser than the reference time, etc. There are more applications</span>
+<span class="sd">        where we expect sorting, filtering by other attributes as well. This method is an advent of such expressions.</span>
+
+<span class="sd">        :param entities: A list of entities.</span>
+<span class="sd">        :type entities: List[BaseEntity]</span>
+<span class="sd">        :return: A list of entities obtained after applying filters.</span>
+<span class="sd">        :rtype: List[BaseEntity]</span>
+<span class="sd">        """</span>
+        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">datetime_filters</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">entities</span>
+
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">select_datetime</span><span class="p">(</span><span class="n">entities</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">datetime_filters</span><span class="p">)</span></div>
+
 <div class="viewcode-block" id="DucklingPlugin.utility"><a class="viewcode-back" href="../../../../source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.utility">[docs]</a>    <span class="k">def</span> <span class="nf">utility</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">:</span> <span class="n">Any</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">List</span><span class="p">[</span><span class="n">BaseEntity</span><span class="p">]:</span>
+        <span class="sd">"""</span>
+<span class="sd">        Produces Duckling entities, runs with a :ref:`Workflow's run&lt;workflow_run&gt;` method.</span>
+
+<span class="sd">        :param args: Expects a tuple of :code:`Tuple[natural language for parsing entities, reference time in seconds, locale]`</span>
+<span class="sd">        :type args: Tuple(str, int, str)</span>
+<span class="sd">        :return: A list of duckling entities.</span>
+<span class="sd">        :rtype: List[BaseEntity]</span>
+<span class="sd">        """</span>
         <span class="n">entities</span> <span class="o">=</span> <span class="p">[]</span>
         <span class="n">input_</span><span class="p">,</span> <span class="n">reference_time</span><span class="p">,</span> <span class="n">locale</span> <span class="o">=</span> <span class="n">args</span>
-
+        <span class="bp">self</span><span class="o">.</span><span class="n">reference_time</span> <span class="o">=</span> <span class="n">reference_time</span>
         <span class="k">try</span><span class="p">:</span>
             <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">input_</span><span class="p">,</span> <span class="nb">str</span><span class="p">):</span>
                 <span class="n">entities</span><span class="o">.</span><span class="n">append</span><span class="p">(</span>
@@ -484,7 +564,8 @@ <h1>Source code for dialogy.preprocess.text.duckling_plugin</h1><div class="high
                 <span class="n">entity</span> <span class="k">for</span> <span class="n">entity_list</span> <span class="ow">in</span> <span class="n">entities</span> <span class="k">for</span> <span class="n">entity</span> <span class="ow">in</span> <span class="n">entity_list</span>
             <span class="p">]</span>
             <span class="n">shaped_entities</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_reshape</span><span class="p">(</span><span class="n">entities_flattened</span><span class="p">)</span>
-            <span class="k">return</span> <span class="n">shaped_entities</span>
+            <span class="n">filtered_entities</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">apply_filters</span><span class="p">(</span><span class="n">shaped_entities</span><span class="p">)</span>
+            <span class="k">return</span> <span class="n">filtered_entities</span>
         <span class="k">except</span> <span class="ne">ValueError</span> <span class="k">as</span> <span class="n">value_error</span><span class="p">:</span>
             <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">value_error</span><span class="p">))</span> <span class="kn">from</span> <span class="nn">value_error</span></div></div>
 </pre></div>
diff --git a/docs/_modules/dialogy/types/entity/base_entity.html b/docs/_modules/dialogy/types/entity/base_entity.html
index 5269b4ed..f57194de 100644
--- a/docs/_modules/dialogy/types/entity/base_entity.html
+++ b/docs/_modules/dialogy/types/entity/base_entity.html
@@ -184,6 +184,7 @@
         </label>
         <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight"><pre>
 <span></span><span class="sd">"""</span>
+<span class="sd">.. _base_entity:</span>
 <span class="sd">Module provides access to a base class to create other entities.</span>
 
 <span class="sd">These methods of this class that are supposed to be overridden:</span>
@@ -200,8 +201,8 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
 <span class="kn">import</span> <span class="nn">attr</span>
 
 <span class="kn">from</span> <span class="nn">dialogy</span> <span class="kn">import</span> <span class="n">constants</span> <span class="k">as</span> <span class="n">const</span>
-<span class="kn">from</span> <span class="nn">dialogy.types.entity.utils</span> <span class="kn">import</span> <span class="n">traverse_dict</span><span class="p">,</span> <span class="n">validate_type</span>
 <span class="kn">from</span> <span class="nn">dialogy.types.plugin</span> <span class="kn">import</span> <span class="n">PluginFn</span>
+<span class="kn">from</span> <span class="nn">dialogy.utils</span> <span class="kn">import</span> <span class="n">traverse_dict</span><span class="p">,</span> <span class="n">validate_type</span>
 
 
 <span class="c1"># = BaseEntity =</span>
@@ -217,7 +218,7 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
     <span class="c1"># **range**</span>
     <span class="c1">#</span>
     <span class="c1"># is the character range in the alternative where the entity is parsed.</span>
-    <span class="nb">range</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span><span class="p">])</span>
+    <span class="nb">range</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span><span class="p">],</span> <span class="nb">repr</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
 
     <span class="c1"># **type**</span>
     <span class="c1">#</span>
@@ -232,7 +233,7 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
     <span class="c1"># **dim**</span>
     <span class="c1">#</span>
     <span class="c1"># is influenced from Duckling's convention of categorization.</span>
-    <span class="n">dim</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+    <span class="n">dim</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="nb">repr</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
 
     <span class="c1"># **parsers**</span>
     <span class="c1">#</span>
@@ -251,7 +252,7 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
     <span class="c1"># **slot_names**</span>
     <span class="c1">#</span>
     <span class="c1"># Entities have awareness of the slots they should fill.</span>
-    <span class="n">slot_names</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span> <span class="n">default</span><span class="o">=</span><span class="n">attr</span><span class="o">.</span><span class="n">Factory</span><span class="p">(</span><span class="nb">list</span><span class="p">))</span>
+    <span class="n">slot_names</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">],</span> <span class="n">default</span><span class="o">=</span><span class="n">attr</span><span class="o">.</span><span class="n">Factory</span><span class="p">(</span><span class="nb">list</span><span class="p">),</span> <span class="nb">repr</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
 
     <span class="c1"># **alternative_index**</span>
     <span class="c1">#</span>
@@ -271,6 +272,7 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
         <span class="nb">type</span><span class="o">=</span><span class="n">List</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]],</span>
         <span class="n">default</span><span class="o">=</span><span class="n">attr</span><span class="o">.</span><span class="n">Factory</span><span class="p">(</span><span class="nb">list</span><span class="p">),</span>
         <span class="n">validator</span><span class="o">=</span><span class="n">attr</span><span class="o">.</span><span class="n">validators</span><span class="o">.</span><span class="n">instance_of</span><span class="p">(</span><span class="n">List</span><span class="p">),</span>
+        <span class="nb">repr</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
     <span class="p">)</span>
 
     <span class="c1"># **values**</span>
@@ -281,23 +283,58 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
     <span class="c1"># **entity_type**</span>
     <span class="c1">#</span>
     <span class="c1"># Mirrors type, to be deprecated.</span>
-    <span class="n">entity_type</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+    <span class="n">entity_type</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="nb">repr</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
 
     <span class="n">__properties_map</span> <span class="o">=</span> <span class="n">const</span><span class="o">.</span><span class="n">BASE_ENTITY_PROPS</span>
 
-    <span class="c1"># == validate ==</span>
+    <span class="k">def</span> <span class="nf">__attrs_post_init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">entity_type</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">type</span>
+
 <div class="viewcode-block" id="BaseEntity.validate"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.validate">[docs]</a>    <span class="nd">@classmethod</span>
     <span class="k">def</span> <span class="nf">validate</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">dict_</span><span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Check attributes of instance match expected types.</span>
 
-<span class="sd">        Args:</span>
-<span class="sd">            dict_ (Dict[str, Any]): A `Dict` where each key is an attribute of the instance and value is the expected type.</span>
+<span class="sd">        :param dict_: A `Dict` where each key is an attribute of the instance and value is the expected type.</span>
+<span class="sd">        :type dict_: Dict[str, Any]</span>
+<span class="sd">        :return: None</span>
+<span class="sd">        :rtype: None</span>
 <span class="sd">        """</span>
         <span class="k">for</span> <span class="n">prop</span><span class="p">,</span> <span class="n">prop_type</span> <span class="ow">in</span> <span class="bp">cls</span><span class="o">.</span><span class="n">__properties_map</span><span class="p">:</span>
             <span class="n">validate_type</span><span class="p">(</span><span class="n">traverse_dict</span><span class="p">(</span><span class="n">dict_</span><span class="p">,</span> <span class="n">prop</span><span class="p">),</span> <span class="n">prop_type</span><span class="p">)</span></div>
 
-    <span class="c1"># == from_dict ==</span>
+<div class="viewcode-block" id="BaseEntity.reshape"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.reshape">[docs]</a>    <span class="nd">@classmethod</span>
+    <span class="k">def</span> <span class="nf">reshape</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">dict_</span><span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]:</span>
+        <span class="sd">"""</span>
+<span class="sd">        :type dict_: Dict[str, Any]</span>
+<span class="sd">        """</span>
+        <span class="n">match_start</span> <span class="o">=</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">START</span><span class="p">]</span>
+        <span class="n">match_end</span> <span class="o">=</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">END</span><span class="p">]</span>
+
+        <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">RANGE</span><span class="p">]</span> <span class="o">=</span> <span class="p">{</span>
+            <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">START</span><span class="p">:</span> <span class="n">match_start</span><span class="p">,</span>
+            <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">END</span><span class="p">:</span> <span class="n">match_end</span><span class="p">,</span>
+        <span class="p">}</span>
+        <span class="c1"># ['body', 'start', 'value', 'end', 'dim', 'latent']</span>
+
+        <span class="c1"># **type** of an entity is same as its **dimension**.</span>
+        <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">TYPE</span><span class="p">]</span> <span class="o">=</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">DIM</span><span class="p">]</span>
+
+        <span class="c1"># This piece is a preparation for multiple entity values.</span>
+        <span class="c1"># So, even though we are confident of the value found, we are still keeping the</span>
+        <span class="c1"># structure.</span>
+        <span class="k">if</span> <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span> <span class="ow">in</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUE</span><span class="p">]:</span>
+            <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span><span class="p">]</span> <span class="o">=</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUE</span><span class="p">][</span>
+                <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span>
+            <span class="p">]</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUE</span><span class="p">]]</span>
+
+        <span class="k">del</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">START</span><span class="p">]</span>
+        <span class="k">del</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">END</span><span class="p">]</span>
+        <span class="k">del</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUE</span><span class="p">]</span>
+        <span class="k">return</span> <span class="n">dict_</span></div>
+
 <div class="viewcode-block" id="BaseEntity.from_dict"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.from_dict">[docs]</a>    <span class="nd">@classmethod</span>
     <span class="k">def</span> <span class="nf">from_dict</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">dict_</span><span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="s2">"BaseEntity"</span><span class="p">:</span>
         <span class="sd">"""</span>
@@ -306,13 +343,15 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
 <span class="sd">        Compliance is verified using the `__validate` method. It is expected that each subclass</span>
 <span class="sd">        will implement their own flavor of `__validate` to check their respective inputs.</span>
 
-<span class="sd">        Returns:</span>
-<span class="sd">            BaseEntity: Instance of class</span>
+<span class="sd">        :param dict_: A dict that provides all the attributes necessary for instantiating this class</span>
+<span class="sd">        :type dict_: Dict[str, Any]</span>
+<span class="sd">        :return: Instance of class</span>
+<span class="sd">        :rtype: BaseEntity</span>
 <span class="sd">        """</span>
+        <span class="n">dict_</span> <span class="o">=</span> <span class="bp">cls</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">dict_</span><span class="p">)</span>
         <span class="bp">cls</span><span class="o">.</span><span class="n">validate</span><span class="p">(</span><span class="n">dict_</span><span class="p">)</span>
         <span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="o">**</span><span class="n">dict_</span><span class="p">)</span></div>
 
-    <span class="c1"># == add_parser ==</span>
 <div class="viewcode-block" id="BaseEntity.add_parser"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.add_parser">[docs]</a>    <span class="k">def</span> <span class="nf">add_parser</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">postprocessor</span><span class="p">:</span> <span class="n">PluginFn</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Update parsers with the postprocessor function name</span>
@@ -320,47 +359,45 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
 <span class="sd">        This helps us identify the progression in which the postprocessing functions</span>
 <span class="sd">        were applied to an entity. This helps in debugging and has no production utility</span>
 
-<span class="sd">        Args:</span>
-<span class="sd">            postprocessor (PluginFn): Plugin function applied to an entity</span>
+<span class="sd">        :param postprocessor: Plugin function applied to an entity</span>
+<span class="sd">        :type postprocessor: PluginFn</span>
+<span class="sd">        :return: None</span>
+<span class="sd">        :rtype: None</span>
 <span class="sd">        """</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">parsers</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">postprocessor</span><span class="o">.</span><span class="vm">__name__</span><span class="p">)</span></div>
 
-    <span class="c1"># == get_value ==</span>
-<div class="viewcode-block" id="BaseEntity.get_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.get_value">[docs]</a>    <span class="k">def</span> <span class="nf">get_value</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
+<div class="viewcode-block" id="BaseEntity.get_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.get_value">[docs]</a>    <span class="k">def</span> <span class="nf">get_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">:</span> <span class="n">Any</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Get value of an entity.</span>
 
 <span class="sd">        The structure of an entity conceals the value in different data structures.</span>
 <span class="sd">        This is sugar for access.</span>
 
-<span class="sd">        Raises:</span>
+<span class="sd">        :return: Arbitrary instance, subclasses should override and return specific types.</span>
+<span class="sd">        :rtype: BaseEntity</span>
+<span class="sd">        :raises:</span>
 <span class="sd">            IndexError: If `values` is not a `list`.</span>
 <span class="sd">            KeyError: If each element in `values` is not a `dict`.</span>
-
-<span class="sd">        Returns:</span>
-<span class="sd">            Any: Arbitrary return value, subclasses should override and return specific types.</span>
 <span class="sd">        """</span>
+        <span class="n">key</span> <span class="o">=</span> <span class="s2">"value"</span>
+        <span class="n">error_message</span> <span class="o">=</span> <span class="sa">f</span><span class="s1">'entity value should be in values[0]["</span><span class="si">{</span><span class="n">key</span><span class="si">}</span><span class="s1">"]'</span>
         <span class="k">try</span><span class="p">:</span>
-            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="s2">"value"</span><span class="p">]</span>
+            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="n">key</span><span class="p">]</span>
         <span class="k">except</span> <span class="ne">IndexError</span> <span class="k">as</span> <span class="n">index_error</span><span class="p">:</span>
-            <span class="k">raise</span> <span class="ne">IndexError</span><span class="p">(</span>
-                <span class="s1">'entity value should be in values[0]["value"]'</span>
-            <span class="p">)</span> <span class="kn">from</span> <span class="nn">index_error</span>
+            <span class="k">raise</span> <span class="ne">IndexError</span><span class="p">(</span><span class="n">error_message</span><span class="p">)</span> <span class="kn">from</span> <span class="nn">index_error</span>
         <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">key_error</span><span class="p">:</span>
-            <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span>
-                <span class="s1">'entity value should be in values[0]["value"]'</span>
-            <span class="p">)</span> <span class="kn">from</span> <span class="nn">key_error</span></div>
+            <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">error_message</span><span class="p">)</span> <span class="kn">from</span> <span class="nn">key_error</span></div>
 
-    <span class="c1"># == copy ==</span>
 <div class="viewcode-block" id="BaseEntity.copy"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.copy">[docs]</a>    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="s2">"BaseEntity"</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Create a deep copy of the instance and return.</span>
 
 <span class="sd">        This is needed to prevent mutation of an original entity.</span>
+<span class="sd">        :return: A copy of BaseEntity that calls this method.</span>
+<span class="sd">        :rtype: BaseEntity</span>
 <span class="sd">        """</span>
         <span class="k">return</span> <span class="n">copy</span><span class="o">.</span><span class="n">deepcopy</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span></div>
 
-    <span class="c1"># == json ==</span>
 <div class="viewcode-block" id="BaseEntity.json"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.json">[docs]</a>    <span class="k">def</span> <span class="nf">json</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">skip</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span> <span class="n">add</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">List</span><span class="p">[</span><span class="nb">str</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]:</span>
@@ -369,36 +406,37 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
 
 <span class="sd">        Applies some expected filters to prevent information bloat.</span>
 
-<span class="sd">        Args:</span>
-<span class="sd">            skip (Optional[List[str]], optional): Names of attributes that should not be included while converting to a dict.</span>
-<span class="sd">            Defaults to None.</span>
+<span class="sd">        Add section for skipping more properties using const.SKIP_ENTITY_ATTRS + [""]</span>
 
-<span class="sd">            add (Optional[List[str]], optional): Names of attributes that should be included while converting to a dict.</span>
+<span class="sd">        :param skip: Names of attributes that should not be included while converting to a dict.</span>
 <span class="sd">            Defaults to None.</span>
-
-<span class="sd">        Returns:</span>
-<span class="sd">            Dict[str, Any]: Dictionary representation of the object</span>
+<span class="sd">        :type skip: Optional[List[str]]</span>
+<span class="sd">        :param add: Names of attributes that should be included while converting to a dict.</span>
+<span class="sd">            Defaults to None.</span>
+<span class="sd">        :type add: Optional[List[str]]</span>
+<span class="sd">        :return: Dictionary representation of the object</span>
+<span class="sd">        :rtype: Dict[str, Any]</span>
 <span class="sd">        """</span>
         <span class="n">skip_</span> <span class="o">=</span> <span class="n">skip</span> <span class="ow">or</span> <span class="n">const</span><span class="o">.</span><span class="n">SKIP_ENTITY_ATTRS</span>
         <span class="k">if</span> <span class="n">add</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">add</span><span class="p">,</span> <span class="nb">list</span><span class="p">):</span>
             <span class="n">skip_</span> <span class="o">=</span> <span class="p">[</span><span class="n">name</span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">const</span><span class="o">.</span><span class="n">SKIP_ENTITY_ATTRS</span> <span class="k">if</span> <span class="n">name</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">add</span><span class="p">]</span>
         <span class="k">return</span> <span class="n">attr</span><span class="o">.</span><span class="n">asdict</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">filter</span><span class="o">=</span><span class="k">lambda</span> <span class="n">attr</span><span class="p">,</span> <span class="n">_</span><span class="p">:</span> <span class="n">attr</span><span class="o">.</span><span class="n">name</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">skip_</span><span class="p">)</span></div>
 
-<div class="viewcode-block" id="BaseEntity.set_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.set_value">[docs]</a>    <span class="k">def</span> <span class="nf">set_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">:</span> <span class="n">Any</span> <span class="o">=</span> <span class="kc">None</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+<div class="viewcode-block" id="BaseEntity.set_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.set_value">[docs]</a>    <span class="k">def</span> <span class="nf">set_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">:</span> <span class="n">Any</span> <span class="o">=</span> <span class="kc">None</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="s2">"BaseEntity"</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Set values and value attribute.</span>
 
-<span class="sd">        Args:</span>
-<span class="sd">            value (Any): The parsed value of an entity token.</span>
-
-<span class="sd">        Returns:</span>
-<span class="sd">            None</span>
+<span class="sd">        :param value: The parsed value of an entity token.</span>
+<span class="sd">        :type value: Any</span>
+<span class="sd">        :return: None</span>
+<span class="sd">        :rtype: None</span>
 <span class="sd">        """</span>
         <span class="k">if</span> <span class="n">value</span> <span class="ow">is</span> <span class="kc">None</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">,</span> <span class="nb">list</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
             <span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="n">const</span><span class="o">.</span><span class="n">VALUE</span><span class="p">]</span>
         <span class="k">else</span><span class="p">:</span>
             <span class="bp">self</span><span class="o">.</span><span class="n">values</span> <span class="o">=</span> <span class="p">[{</span><span class="n">const</span><span class="o">.</span><span class="n">VALUE</span><span class="p">:</span> <span class="n">value</span><span class="p">}]</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">value</span></div></div>
+            <span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">value</span>
+        <span class="k">return</span> <span class="bp">self</span></div></div>
 
 
 <span class="c1"># = entity_synthesis =</span>
@@ -406,16 +444,17 @@ <h1>Source code for dialogy.types.entity.base_entity</h1><div class="highlight">
     <span class="sd">"""</span>
 <span class="sd">    Update a property=`property_` of a BaseEntity, with a given value=`value`.</span>
 
-<span class="sd">    Args:</span>
-<span class="sd">        entity (BaseEntity): The BaseEntity instance to update.</span>
-<span class="sd">        property_ (str): The attribute of a given entity that should be updated.</span>
-<span class="sd">        value (Any): The value that should updated.</span>
-
-<span class="sd">    Raises:</span>
-<span class="sd">        TypeError: If `entity` is not a BaseEntity.</span>
-
-<span class="sd">    Returns:</span>
-<span class="sd">        BaseEntity: modified instance of BaseEntity.</span>
+<span class="sd">    .. warning:: This is an unsafe method. Use with caution as it doesn't check the type of</span>
+<span class="sd">        the new value being type safe.</span>
+
+<span class="sd">    :param entity: A BaseEntity instance.</span>
+<span class="sd">    :type entity: BaseEntity</span>
+<span class="sd">    :param property_: An attribute of BaseEntity that should be changed.</span>
+<span class="sd">    :type property_: str</span>
+<span class="sd">    :param value: The value to replace within a BaseEntity instance.</span>
+<span class="sd">    :type value: Any</span>
+<span class="sd">    :return: A copy of BaseEntity instance used in this function with modifications.</span>
+<span class="sd">    :rtype: BaseEntity</span>
 <span class="sd">    """</span>
     <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">BaseEntity</span><span class="p">):</span>
         <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">entity</span><span class="si">}</span><span class="s2"> has type </span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="n">entity</span><span class="p">)</span><span class="si">}</span><span class="s2"> expected BaseEntity"</span><span class="p">)</span>
diff --git a/docs/_modules/dialogy/types/entity/time_entity.html b/docs/_modules/dialogy/types/entity/time_entity.html
index 3037af8f..f93a7a3f 100644
--- a/docs/_modules/dialogy/types/entity/time_entity.html
+++ b/docs/_modules/dialogy/types/entity/time_entity.html
@@ -184,16 +184,19 @@
         </label>
         <h1>Source code for dialogy.types.entity.time_entity</h1><div class="highlight"><pre>
 <span></span><span class="sd">"""</span>
+<span class="sd">.. _time_entity:</span>
 <span class="sd">Module provides access to entity types that can be parsed to obtain datetime values.</span>
 
 <span class="sd">Import classes:</span>
 <span class="sd">    - TimeEntity</span>
 <span class="sd">"""</span>
-<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Optional</span>
+<span class="kn">from</span> <span class="nn">datetime</span> <span class="kn">import</span> <span class="n">datetime</span>
+<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Any</span><span class="p">,</span> <span class="n">Dict</span><span class="p">,</span> <span class="n">Optional</span>
 
 <span class="kn">import</span> <span class="nn">attr</span>
+<span class="kn">import</span> <span class="nn">pydash</span> <span class="k">as</span> <span class="nn">py_</span>  <span class="c1"># type: ignore</span>
 
-<span class="kn">from</span> <span class="nn">dialogy</span> <span class="kn">import</span> <span class="n">constants</span>
+<span class="kn">from</span> <span class="nn">dialogy</span> <span class="kn">import</span> <span class="n">constants</span> <span class="k">as</span> <span class="n">const</span>
 <span class="kn">from</span> <span class="nn">dialogy.types.entity.numerical_entity</span> <span class="kn">import</span> <span class="n">NumericalEntity</span>
 
 
@@ -213,14 +216,178 @@ <h1>Source code for dialogy.types.entity.time_entity</h1><div class="highlight">
 
     <span class="n">dim</span> <span class="o">=</span> <span class="s2">"time"</span>
     <span class="n">grain</span> <span class="o">=</span> <span class="n">attr</span><span class="o">.</span><span class="n">ib</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="nb">str</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">validator</span><span class="o">=</span><span class="n">attr</span><span class="o">.</span><span class="n">validators</span><span class="o">.</span><span class="n">instance_of</span><span class="p">(</span><span class="nb">str</span><span class="p">))</span>
-    <span class="n">__properties_map</span> <span class="o">=</span> <span class="n">constants</span><span class="o">.</span><span class="n">TIME_ENTITY_PROPS</span>
+    <span class="n">__properties_map</span> <span class="o">=</span> <span class="n">const</span><span class="o">.</span><span class="n">TIME_ENTITY_PROPS</span>
+
+<div class="viewcode-block" id="TimeEntity.reshape"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.reshape">[docs]</a>    <span class="nd">@classmethod</span>
+    <span class="k">def</span> <span class="nf">reshape</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">dict_</span><span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]:</span>
+        <span class="n">dict_</span> <span class="o">=</span> <span class="nb">super</span><span class="p">(</span><span class="n">TimeEntity</span><span class="p">,</span> <span class="bp">cls</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">dict_</span><span class="p">)</span>
+        <span class="c1"># Pulling out the value of entity's **grain**. The value of **grain** helps</span>
+        <span class="c1"># us understand the precision of the entity. Usually present for `Time` dimension</span>
+        <span class="c1"># expect "year", "month", "day", etc.</span>
+        <span class="k">if</span> <span class="nb">all</span><span class="p">(</span>
+            <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">GRAIN</span> <span class="ow">in</span> <span class="n">value</span> <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span><span class="p">]</span>
+        <span class="p">):</span>
+            <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">GRAIN</span><span class="p">]</span> <span class="o">=</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span><span class="p">][</span><span class="mi">0</span><span class="p">][</span>
+                <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">GRAIN</span>
+            <span class="p">]</span>
+        <span class="k">return</span> <span class="n">dict_</span></div>
+
+<div class="viewcode-block" id="TimeEntity.get_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.get_value">[docs]</a>    <span class="k">def</span> <span class="nf">get_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">date</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Optional</span><span class="p">[</span><span class="n">datetime</span><span class="p">]:</span>  <span class="c1"># type: ignore # pylint: disable=arguments-differ</span>
+        <span class="sd">"""</span>
+<span class="sd">        Return the date string in ISO format from the dictionary passed</span>
+
+<span class="sd">        .. code-block:: python</span>
+
+<span class="sd">            date = {</span>
+<span class="sd">                "value": "2021-04-17T16:00:00.000+05:30",</span>
+<span class="sd">                "grain": "hour",</span>
+<span class="sd">                "type": "value"</span>
+<span class="sd">            }</span>
+
+<span class="sd">        :param date: Dictionary which stores the datetime in ISO format, grain and type</span>
+<span class="sd">        :type date: Dict[str, str]</span>
+<span class="sd">        :return: :code:`date["value"]`</span>
+<span class="sd">        :rtype: Optional[datetime]</span>
+<span class="sd">        """</span>
+        <span class="n">entity_date_value</span> <span class="o">=</span> <span class="p">(</span>
+            <span class="nb">super</span><span class="p">(</span><span class="n">TimeEntity</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">get_value</span><span class="p">()</span> <span class="k">if</span> <span class="ow">not</span> <span class="n">date</span> <span class="k">else</span> <span class="n">date</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">"value"</span><span class="p">)</span>
+        <span class="p">)</span>
+        <span class="k">if</span> <span class="n">entity_date_value</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">datetime</span><span class="o">.</span><span class="n">fromisoformat</span><span class="p">(</span><span class="n">entity_date_value</span><span class="p">)</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="sa">f</span><span class="s2">"Expected key `value` in </span><span class="si">{</span><span class="n">date</span><span class="si">}</span><span class="s2"> for </span><span class="si">{</span><span class="bp">self</span><span class="si">}</span><span class="s2">"</span><span class="p">)</span></div>
+
+<div class="viewcode-block" id="TimeEntity.is_uniq_date_from_values"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.is_uniq_date_from_values">[docs]</a>    <span class="k">def</span> <span class="nf">is_uniq_date_from_values</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">bool</span><span class="p">:</span>
+        <span class="sd">"""</span>
+<span class="sd">        Check a list has a unique day</span>
+
+<span class="sd">        Where day is the date number for a month.</span>
+<span class="sd">        Ex: for "2021-04-17T16:00:00.000+05:30", the day is 17</span>
+
+<span class="sd">        .. ipython :: python</span>
+
+<span class="sd">            from dialogy.types import TimeEntity</span>
+<span class="sd">            duckling_time_entity = {</span>
+<span class="sd">                "body": "july 19",</span>
+<span class="sd">                "start": 0,</span>
+<span class="sd">                "value": {</span>
+<span class="sd">                "values": [</span>
+<span class="sd">                    {</span>
+<span class="sd">                    "value": "2021-07-19T00:00:00.000+05:30",</span>
+<span class="sd">                    "grain": "day",</span>
+<span class="sd">                    "type": "value"</span>
+<span class="sd">                    },</span>
+<span class="sd">                    {</span>
+<span class="sd">                    "value": "2022-07-19T00:00:00.000+05:30",</span>
+<span class="sd">                    "grain": "day",</span>
+<span class="sd">                    "type": "value"</span>
+<span class="sd">                    },</span>
+<span class="sd">                    {</span>
+<span class="sd">                    "value": "2023-07-19T00:00:00.000+05:30",</span>
+<span class="sd">                    "grain": "day",</span>
+<span class="sd">                    "type": "value"</span>
+<span class="sd">                    }</span>
+<span class="sd">                ],</span>
+<span class="sd">                "value": "2021-07-19T00:00:00.000+05:30",</span>
+<span class="sd">                "grain": "day",</span>
+<span class="sd">                "type": "value"</span>
+<span class="sd">                },</span>
+<span class="sd">                "end": 7,</span>
+<span class="sd">                "dim": "time",</span>
+<span class="sd">                "latent": False</span>
+<span class="sd">            }</span>
+<span class="sd">            time_entity = TimeEntity.from_dict(duckling_time_entity)</span>
+<span class="sd">            time_entity.is_uniq_date_from_values()</span>
+
+
+<span class="sd">        :return: True if there is a unique day in all datetime values</span>
+<span class="sd">        :rtype: bool</span>
+<span class="sd">        """</span>
+        <span class="n">dates</span> <span class="o">=</span> <span class="p">[]</span>
+        <span class="k">for</span> <span class="n">date_value</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">:</span>
+            <span class="n">date_</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">get_value</span><span class="p">(</span><span class="n">date_value</span><span class="p">)</span>
+            <span class="k">if</span> <span class="n">date_</span><span class="p">:</span>
+                <span class="n">dates</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">date_</span><span class="o">.</span><span class="n">day</span><span class="p">)</span>
+        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="n">py_</span><span class="o">.</span><span class="n">uniq</span><span class="p">(</span><span class="n">dates</span><span class="p">))</span> <span class="o">==</span> <span class="mi">1</span></div>
+
+<div class="viewcode-block" id="TimeEntity.is_uniq_day_from_values"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.is_uniq_day_from_values">[docs]</a>    <span class="k">def</span> <span class="nf">is_uniq_day_from_values</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">bool</span><span class="p">:</span>
+        <span class="sd">"""</span>
+<span class="sd">        Check a list has a unique weekday</span>
+
+<span class="sd">        Where weekday ranges from 0 for Monday till 6 for Sunday</span>
+<span class="sd">        Ex: for "2021-04-17T16:00:00.000+05:30", the weekday is 5 (Saturday)</span>
+
+<span class="sd">        :return: True if there is a unique weekday in all datetime values</span>
+<span class="sd">        :rtype: bool</span>
+<span class="sd">        """</span>
+        <span class="n">dates</span> <span class="o">=</span> <span class="p">[]</span>
+        <span class="k">for</span> <span class="n">date_value</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">:</span>
+            <span class="n">date_</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">get_value</span><span class="p">(</span><span class="n">date_value</span><span class="p">)</span>
+            <span class="k">if</span> <span class="n">date_</span><span class="p">:</span>
+                <span class="n">dates</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">date_</span><span class="p">)</span>
+        <span class="c1"># Duckling may return 3 datetime values in chronological order.</span>
+        <span class="c1"># For cases where someone has said "Monday", we will get 3 values,</span>
+        <span class="c1"># each value a week apart.</span>
+        <span class="c1"># We are pairing these dates and checking whether the difference is a week (7 days).</span>
+        <span class="c1"># For example, if our dates are [21-04-2021, 28-04-2021, 05-05-2021],</span>
+        <span class="c1"># then we generate pairs as (21-04-2021, 28-04-2021) and (28-04-2021, 05-05-2021).</span>
+        <span class="c1"># If the difference between these dates is divisible by seven,</span>
+        <span class="c1"># then we are clear that the input was a weekday.</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="n">dates</span><span class="p">:</span>
+            <span class="k">return</span> <span class="kc">False</span>
+        <span class="k">return</span> <span class="nb">all</span><span class="p">(</span>
+            <span class="nb">abs</span><span class="p">((</span><span class="nb">next</span> <span class="o">-</span> <span class="n">prev</span><span class="p">)</span><span class="o">.</span><span class="n">days</span><span class="p">)</span> <span class="o">%</span> <span class="mi">7</span> <span class="o">==</span> <span class="mi">0</span>
+            <span class="k">for</span> <span class="p">(</span><span class="n">prev</span><span class="p">,</span> <span class="nb">next</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">dates</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="n">dates</span><span class="p">[</span><span class="mi">1</span><span class="p">:])</span>
+        <span class="p">)</span></div>
+
+<div class="viewcode-block" id="TimeEntity.set_entity_type"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.set_entity_type">[docs]</a>    <span class="k">def</span> <span class="nf">set_entity_type</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
+        <span class="sd">"""</span>
+<span class="sd">        Returns the type for this entity</span>
+
+<span class="sd">        To pinpoint a time for any action, we need both DATE (either explicit or inferred) and TIME.</span>
+<span class="sd">        We can get these in 3 possible manners:</span>
+
+<span class="sd">        - both DATE and TIME, the entity type here will be DATETIME</span>
+<span class="sd">            - Positive examples: tonight, tomorrow 4pm, 7th april 2019 6pm, last 3 hours (Because it tells us about the date as well, that is today)</span>
+<span class="sd">            - Negative examples: Yesterday I went to park at 3pm (because the user did not say yesterday and 3pm together)</span>
+<span class="sd">        - only DATE, the entity type here will be DATE</span>
+<span class="sd">            - Positive examples: last month, last year, last 3 months, last 6 months, tomorrow, 27th oct 1996, 1st October 2019 till yesterday, yesterday, today, tomorrow, October, 2019, 27th October 1996 to 29th October 1996 etc</span>
+<span class="sd">            - Negative examples: month, year, 6 months, 3 months (Since these do not have a fixed start and end date, it could have been 6 months from today, 6 months from tomorrow, previous 6 months. Therefore it only tells us a duration.)</span>
+<span class="sd">        - only TIME, the entity type here will be TIME</span>
+<span class="sd">            - Positive examples: 3pm, 5pm, night, morning, etc</span>
+<span class="sd">            - Negative examples: tonight (because the date part today is in it), tomorrow night, 6th April 5pm, 7 hours (duration because they didn't mention a start/end time. It could be 7 hours from any time) etc</span>
+
+<span class="sd">        if we get the grain as one of ("day", "week", "month", "quarter", "year"),</span>
+<span class="sd">        then the entity type is DATE</span>
+<span class="sd">        if we get grain as one of ("hour", "second", "minute") and we only have 1 value in `self.values`,</span>
+<span class="sd">        then the entity type is DATETIME.</span>
+<span class="sd">        if we get grain as one of ("hour", "second", "minute") and we have either a unique date or a unique weekday,</span>
+<span class="sd">        then the entity type is DATETIME.</span>
+<span class="sd">        else the entity type is TIME.</span>
+
+<span class="sd">        :return: one of (date, time, datetime)</span>
+<span class="sd">        :rtype: str</span>
+<span class="sd">        """</span>
+        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grain</span> <span class="ow">in</span> <span class="n">const</span><span class="o">.</span><span class="n">DATE_UNITS</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">const</span><span class="o">.</span><span class="n">DATE</span>
+        <span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">grain</span> <span class="ow">in</span> <span class="n">const</span><span class="o">.</span><span class="n">TIME_UNITS</span> <span class="ow">and</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">const</span><span class="o">.</span><span class="n">DATETIME</span>
+        <span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">is_uniq_date_from_values</span><span class="p">()</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">is_uniq_day_from_values</span><span class="p">():</span>
+            <span class="k">return</span> <span class="n">const</span><span class="o">.</span><span class="n">DATETIME</span>
+        <span class="k">elif</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">const</span><span class="o">.</span><span class="n">TIME</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="sa">f</span><span class="s2">"Expected at least 1 value in </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="si">}</span><span class="s2"> for </span><span class="si">{</span><span class="bp">self</span><span class="si">}</span><span class="s2">"</span><span class="p">)</span></div>
 
     <span class="k">def</span> <span class="nf">__attrs_post_init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">post_init</span><span class="p">()</span>
+
+<div class="viewcode-block" id="TimeEntity.post_init"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.post_init">[docs]</a>    <span class="k">def</span> <span class="nf">post_init</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="n">grain_</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>
         <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">,</span> <span class="nb">list</span><span class="p">)</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">:</span>
-            <span class="n">grain_</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">"grain"</span><span class="p">)</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">grain</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">entity_type</span> <span class="o">=</span> <span class="n">grain_</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">type</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">type</span> <span class="o">=</span> <span class="n">grain_</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">type</span></div>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grain</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">"grain"</span><span class="p">)</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">grain</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">entity_type</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">set_entity_type</span><span class="p">()</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">type</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">entity_type</span></div></div>
 </pre></div>
       </article>
       <footer>
diff --git a/docs/_modules/dialogy/types/entity/time_interval_entity.html b/docs/_modules/dialogy/types/entity/time_interval_entity.html
index df631ad2..028d205e 100644
--- a/docs/_modules/dialogy/types/entity/time_interval_entity.html
+++ b/docs/_modules/dialogy/types/entity/time_interval_entity.html
@@ -184,18 +184,19 @@
         </label>
         <h1>Source code for dialogy.types.entity.time_interval_entity</h1><div class="highlight"><pre>
 <span></span><span class="sd">"""</span>
+<span class="sd">.. _time_interval_entity:</span>
 <span class="sd">Module provides access to entity types that can be parsed to obtain intervals of datetime.</span>
 
 <span class="sd">Import classes:</span>
 <span class="sd">    - TimeIntervalEntity</span>
 <span class="sd">"""</span>
+<span class="kn">from</span> <span class="nn">datetime</span> <span class="kn">import</span> <span class="n">datetime</span>
 <span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Any</span><span class="p">,</span> <span class="n">Dict</span><span class="p">,</span> <span class="n">Optional</span>
 
 <span class="kn">import</span> <span class="nn">attr</span>
 
-<span class="kn">from</span> <span class="nn">dialogy</span> <span class="kn">import</span> <span class="n">constants</span>
 <span class="kn">from</span> <span class="nn">dialogy</span> <span class="kn">import</span> <span class="n">constants</span> <span class="k">as</span> <span class="n">const</span>
-<span class="kn">from</span> <span class="nn">dialogy.types.entity.time_entity</span> <span class="kn">import</span> <span class="n">TimeEntity</span>
+<span class="kn">from</span> <span class="nn">dialogy.types.entity</span> <span class="kn">import</span> <span class="n">TimeEntity</span>
 
 
 <div class="viewcode-block" id="TimeIntervalEntity"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity">[docs]</a><span class="nd">@attr</span><span class="o">.</span><span class="n">s</span>
@@ -213,9 +214,55 @@ <h1>Source code for dialogy.types.entity.time_interval_entity</h1><div class="hi
 
     <span class="n">origin</span> <span class="o">=</span> <span class="s2">"interval"</span>
     <span class="n">dim</span> <span class="o">=</span> <span class="s2">"time"</span>
-    <span class="n">__properties_map</span> <span class="o">=</span> <span class="n">constants</span><span class="o">.</span><span class="n">TIME_ENTITY_PROPS</span>
+    <span class="n">__properties_map</span> <span class="o">=</span> <span class="n">const</span><span class="o">.</span><span class="n">TIME_ENTITY_PROPS</span>
 
-<div class="viewcode-block" id="TimeIntervalEntity.set_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.set_value">[docs]</a>    <span class="k">def</span> <span class="nf">set_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+<div class="viewcode-block" id="TimeIntervalEntity.reshape"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.reshape">[docs]</a>    <span class="nd">@classmethod</span>
+    <span class="k">def</span> <span class="nf">reshape</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">dict_</span><span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]:</span>
+        <span class="n">dict_</span> <span class="o">=</span> <span class="nb">super</span><span class="p">(</span><span class="n">TimeIntervalEntity</span><span class="p">,</span> <span class="bp">cls</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">dict_</span><span class="p">)</span>
+        <span class="k">if</span> <span class="nb">all</span><span class="p">(</span>
+            <span class="n">value</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">TYPE</span><span class="p">]</span> <span class="o">==</span> <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">INTERVAL</span>
+            <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span><span class="p">]</span>
+        <span class="p">):</span>
+            <span class="n">date_range</span> <span class="o">=</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">get</span><span class="p">(</span>
+                <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">FROM</span>
+            <span class="p">)</span> <span class="ow">or</span> <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUES</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">TO</span><span class="p">)</span>
+            <span class="k">if</span> <span class="ow">not</span> <span class="n">date_range</span><span class="p">:</span>
+                <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">dict_</span><span class="si">}</span><span class="s2"> does not match TimeIntervalEntity format"</span><span class="p">)</span>
+            <span class="n">dict_</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">GRAIN</span><span class="p">]</span> <span class="o">=</span> <span class="n">date_range</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">GRAIN</span><span class="p">]</span>
+        <span class="k">return</span> <span class="n">dict_</span></div>
+
+<div class="viewcode-block" id="TimeIntervalEntity.get_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.get_value">[docs]</a>    <span class="k">def</span> <span class="nf">get_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">date</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Optional</span><span class="p">[</span><span class="n">datetime</span><span class="p">]:</span>  <span class="c1"># type: ignore # pylint: disable=arguments-differ</span>
+        <span class="sd">"""</span>
+<span class="sd">        Return the date string in ISO format from the dictionary passed</span>
+
+<span class="sd">        .. code-block:: python</span>
+
+<span class="sd">            date = {</span>
+<span class="sd">                "from": {</span>
+<span class="sd">                    "value": "2021-04-16T16:00:00.000+05:30",</span>
+<span class="sd">                    "grain": "hour"</span>
+<span class="sd">                },</span>
+<span class="sd">                "type": "interval"</span>
+<span class="sd">            }</span>
+
+<span class="sd">        :param date: Dictionary which stores the datetime in ISO format, grain and type</span>
+<span class="sd">        :type date: Dict[str, str]</span>
+<span class="sd">        :return: :code:`date["value"]`</span>
+<span class="sd">        :rtype: Optional[datetime]</span>
+<span class="sd">        """</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="n">date</span><span class="p">:</span>
+            <span class="n">date_dict</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">value</span><span class="p">[</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">FROM</span> <span class="ow">or</span> <span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">TO</span><span class="p">]</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="n">date_dict</span> <span class="o">=</span> <span class="n">date</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">FROM</span><span class="p">)</span> <span class="ow">or</span> <span class="n">date</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">TO</span><span class="p">)</span>
+
+        <span class="k">if</span> <span class="n">date_dict</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">datetime</span><span class="o">.</span><span class="n">fromisoformat</span><span class="p">(</span><span class="n">date_dict</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">const</span><span class="o">.</span><span class="n">EntityKeys</span><span class="o">.</span><span class="n">VALUE</span><span class="p">))</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span>
+                <span class="sa">f</span><span class="s2">"Expected at least 1 of `from` or `to` in </span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="si">}</span><span class="s2"> for </span><span class="si">{</span><span class="bp">self</span><span class="si">}</span><span class="s2">"</span>
+            <span class="p">)</span></div>
+
+<div class="viewcode-block" id="TimeIntervalEntity.set_value"><a class="viewcode-back" href="../../../../source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.set_value">[docs]</a>    <span class="k">def</span> <span class="nf">set_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="s2">"TimeIntervalEntity"</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Set values and value attribute.</span>
 
@@ -229,10 +276,8 @@ <h1>Source code for dialogy.types.entity.time_interval_entity</h1><div class="hi
             <span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
         <span class="k">else</span><span class="p">:</span>
             <span class="k">if</span> <span class="n">value</span><span class="p">:</span>
-                <span class="k">if</span> <span class="p">(</span>
-                    <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="nb">dict</span><span class="p">)</span>
-                    <span class="ow">and</span> <span class="n">const</span><span class="o">.</span><span class="n">TO</span> <span class="ow">in</span> <span class="n">value</span>
-                    <span class="ow">and</span> <span class="n">const</span><span class="o">.</span><span class="n">FROM</span> <span class="ow">in</span> <span class="n">value</span>
+                <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="nb">dict</span><span class="p">)</span> <span class="ow">and</span> <span class="p">(</span>
+                    <span class="n">const</span><span class="o">.</span><span class="n">FROM</span> <span class="ow">in</span> <span class="n">value</span> <span class="ow">or</span> <span class="n">const</span><span class="o">.</span><span class="n">TO</span> <span class="ow">in</span> <span class="n">value</span>
                 <span class="p">):</span>
                     <span class="bp">self</span><span class="o">.</span><span class="n">values</span> <span class="o">=</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span>
                     <span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">value</span>
@@ -246,7 +291,11 @@ <h1>Source code for dialogy.types.entity.time_interval_entity</h1><div class="hi
                     <span class="s2">"Either values should be a non empty list"</span>
                     <span class="s2">" or value should look like: {'to': ...,  'from': ...}"</span>
                     <span class="sa">f</span><span class="s2">" but </span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="n">value</span><span class="p">)</span><span class="si">}</span><span class="s2"> found."</span>
-                <span class="p">)</span></div></div>
+                <span class="p">)</span>
+        <span class="k">return</span> <span class="bp">self</span></div>
+
+    <span class="k">def</span> <span class="nf">__attrs_post_init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">post_init</span><span class="p">()</span></div>
 </pre></div>
       </article>
       <footer>
diff --git a/docs/_modules/dialogy/workflow/workflow.html b/docs/_modules/dialogy/workflow/workflow.html
index 73b1c95a..ca9283ee 100644
--- a/docs/_modules/dialogy/workflow/workflow.html
+++ b/docs/_modules/dialogy/workflow/workflow.html
@@ -184,33 +184,66 @@
         </label>
         <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
 <span></span><span class="sd">"""</span>
-<span class="sd">A `workflow` is supposed to run tasks that can be anticipated well in advance. We are prioritizing tasks that can be performed in production</span>
-<span class="sd">so you may find it odd to miss `train` and `test` methods. This is a deliberate decision since that choice is upto the user and a `workflow`</span>
-<span class="sd">targets performance in a production environment, where `train` and `test` are not the expected set of tasks, rather `inference` is.</span>
+<span class="sd">.. _workflow:</span>
 
-<span class="sd">1. Eliminate low-confidence output.</span>
-<span class="sd">2. Slot-filling.</span>
-<span class="sd">3. Sorting items by order of confidence.</span>
+<span class="sd">A :code:`workflow` is supposed to run tasks that can be anticipated well in advance.</span>
 
-<span class="sd">_What's slot filling?_</span>
-<span class="sd">&gt; The goal of Slot Filling is to identify from a running dialog, different slots, which correspond to different parameters of the user’s query. For instance, when a user queries for nearby restaurants, key slots for location and preferred food are required for a dialog system to retrieve the appropriate information. Thus, the main challenge in the slot-filling task is to extract the target entity.</span>
+<span class="sd">Here are few demo's where you can see mock :code:`workflow` in action.</span>
 
-<span class="sd">[Tutorial](../../tests/workflow/test_workflow.html)</span>
+<span class="sd">- :ref:`RuleBasedSlotFillerPlugin&lt;rule_slot_filler&gt;`</span>
+<span class="sd">- :ref:`VotePlugin&lt;vote_plugin&gt;`</span>
+<span class="sd">- :ref:`DucklingPlugin&lt;duckling_plugin&gt;`</span>
 
-<span class="sd">Import Class:</span>
-<span class="sd">    - Workflow</span>
+<span class="sd">A workflow is a hollow conduit, think of a vertically hanging pipe without any medium. If you were to drop a block of ...</span>
+<span class="sd">`anything`? through it, it would pass through with a thud on the ground `(yes we assumed gravity)`.</span>
+
+<span class="sd">Structure</span>
+<span class="sd">----------</span>
+
+<span class="sd">A workflow allows flexibility, that's why. There is very little structure to it. We have:</span>
+
+<span class="sd">- input</span>
+<span class="sd">- output</span>
+<span class="sd">- preprocessors</span>
+<span class="sd">- postprocessors</span>
+
+<span class="sd">Apart from these, we expect at the core, an inference function with machine learning models. Which ones? A N Y ones.</span>
+<span class="sd">As long as you have the compute, there is no restriction. Use statistical models or DL or a bunch of conditions,</span>
+<span class="sd">your :ref:`Workflow &lt;Workflow&gt;` won't judge you.</span>
+
+<span class="sd">Advantages</span>
+<span class="sd">-----------</span>
+
+<span class="sd">The :ref:`Plugin&lt;plugin&gt;` concept takes care of the sauciness 🍅 of this project. Any functionality can be bundled into</span>
+<span class="sd">a :ref:`Plugin&lt;plugin&gt;` and they are portable over to foreign workflows. A :ref:`Plugin&lt;plugin&gt;` proxies inputs through</span>
+<span class="sd">an :code:`access` function (an argument to every :ref:`Plugin&lt;plugin&gt;`) and relays output through a :code:`mutate`</span>
+<span class="sd">function (another argument for every :ref:`Plugin&lt;plugin&gt;`). These two functions define interactions between many many</span>
+<span class="sd">(sic) :ref:`Plugins&lt;plugin&gt;` without knowing the inner workings of a :ref:`Workflow &lt;workflow&gt;`.</span>
+
+<span class="sd">Take a look at :ref:`DucklingPlugin &lt;duckling_plugin&gt;`, this plugin handles inputs, manages the default :code:`json` output</span>
+<span class="sd">into neatly bundled :ref:`BaseEntity &lt;base_entity&gt;` and other similar classes. Another plugin</span>
+<span class="sd">:ref:`RuleBasedSlotFillerPlugin&lt;rule_slot_filler&gt;` takes care of slot names and the entity types that should be filled</span>
+<span class="sd">within.</span>
+
+<span class="sd">If your classifier predicts an :ref:`Intent&lt;intent&gt;` with :ref:`Slots&lt;slot&gt;` supporting any of those entities, then</span>
+<span class="sd">slot-filling is not a worry.</span>
+
+<span class="sd">The aim of this project is to be largest supplier of plugins for SLU applications.</span>
+
+<span class="sd">.. warning:: The :ref:`Workflow&lt;workflow&gt;` class is not supposed to be used as it is. Ideally it should have been an</span>
+<span class="sd">    abstract class. There are some design considerations which make that a bad choice. We want methods to be overridden</span>
+<span class="sd">    to offer flexibility of use.</span>
 <span class="sd">"""</span>
 <span class="kn">from</span> <span class="nn">pprint</span> <span class="kn">import</span> <span class="n">pformat</span>
 <span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Any</span><span class="p">,</span> <span class="n">Callable</span><span class="p">,</span> <span class="n">List</span><span class="p">,</span> <span class="n">Optional</span>
 
 <span class="kn">from</span> <span class="nn">dialogy</span> <span class="kn">import</span> <span class="n">constants</span>
-<span class="kn">from</span> <span class="nn">dialogy.utils.logger</span> <span class="kn">import</span> <span class="n">change_log_level</span><span class="p">,</span> <span class="n">log</span>
+<span class="kn">from</span> <span class="nn">dialogy.utils.logger</span> <span class="kn">import</span> <span class="n">dbg</span><span class="p">,</span> <span class="n">log</span>
 
 <span class="n">PluginFn</span> <span class="o">=</span> <span class="n">Callable</span><span class="p">[[</span><span class="s2">"Workflow"</span><span class="p">],</span> <span class="kc">None</span><span class="p">]</span>
 
-<span class="c1"># = Workflow =</span>
-<div class="viewcode-block" id="Workflow"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow">[docs]</a><span class="k">class</span> <span class="nc">Workflow</span><span class="p">:</span>
 
+<div class="viewcode-block" id="Workflow"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow">[docs]</a><span class="k">class</span> <span class="nc">Workflow</span><span class="p">:</span>
     <span class="sd">"""</span>
 <span class="sd">    This is a light but fairly flexible workflow for building a machine learning pipeline.</span>
 
@@ -218,19 +251,18 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
 <span class="sd">    - A list of pre-processing functions.</span>
 <span class="sd">    - A list of post-processing functions.</span>
 
-<span class="sd">    _Why are some methods raising NotImplementedError?_</span>
-<span class="sd">    &gt; This class is not supposed to be used as it is. Ideally this should have been an abstract class,</span>
-<span class="sd">    there are some design considerations which make that a bad choice. We want methods to be overridden</span>
-<span class="sd">    to offer flexibility of use.</span>
-
 <span class="sd">    Abstract classes put constraints on method signatures which isn't desired because a couple of methods</span>
 <span class="sd">    here could use more arguments, say, `load_model()` requires `path` and `version` and in some other cases</span>
 <span class="sd">    `path`, `version` and `language`.</span>
 
-<span class="sd">    All the attributes of the class that are meant for private use, have `__` preceeding their names.</span>
+<span class="sd">    :param preprocessors: A list of functions to execute before inference.</span>
+<span class="sd">    :type preprocessors: Optional[List[PluginFn]]</span>
+<span class="sd">    :param postprocessors: A list of functions to execute after inference.</span>
+<span class="sd">    :type postprocessors: Optional[List[PluginFn]]</span>
+<span class="sd">    :param debug: log level shifts to debug if True.</span>
+<span class="sd">    :type debug: bool</span>
 <span class="sd">    """</span>
 
-    <span class="c1"># == __init__ ==</span>
     <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span>
         <span class="n">preprocessors</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="n">List</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">]]</span> <span class="o">=</span> <span class="kc">None</span><span class="p">,</span>
@@ -238,41 +270,9 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
         <span class="n">debug</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="kc">False</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
-<span class="sd">        Setup a Workflow.</span>
-
-<span class="sd">        Setup a list of functions to execute before and after `.inference(...)` call.</span>
-
-<span class="sd">        Attributes:</span>
-
-<span class="sd">        - input (`Any`): The input to a workflow. This is supposed to be flexible.</span>
-<span class="sd">        - output (`Any`): The outputs of a workflow. This is supposed to be flexible.</span>
-<span class="sd">        - __preprocessors (`List[PluginFn]`): A list of functions to execute before inference.</span>
-<span class="sd">        - __postprocessors (`List[PluginFn]`): A list of functions to execute after inference.</span>
-
-<span class="sd">        Methods:</span>
-
-<span class="sd">        - load_model: Load models</span>
-<span class="sd">        - update: Update input and output attributes. This is the effect of running either processors.</span>
-<span class="sd">        - preprocess: Update input attributes. This is the effect of running pre-processors.</span>
-<span class="sd">        - postprocess: Update output attributes. This is the effect of running post-processors.</span>
-<span class="sd">        - inference: Model related functionality.</span>
-<span class="sd">        - run: Wraps over pre/post processing and inference.</span>
-<span class="sd">        - __log: Log the changes in the input/output as pre/post processing functions execute. REQUIRES log-level set to `DEBUG`.</span>
-
-<span class="sd">        Args:</span>
-
-<span class="sd">        - preprocessors (`Optional[List[PluginFn]]`): A list of functions to execute before inference. Defaults to None.</span>
-<span class="sd">        - postprocessors (`Optional[List[PluginFn]]`): A list of functions to execute after inference. Defaults to None.</span>
-<span class="sd">        - debug (Optional[`bool`]): Changes to input/output are logged if log-level is set to `DEBUG`. Defaults to False.</span>
+<span class="sd">        constructor.</span>
 <span class="sd">        """</span>
-        <span class="c1"># **input**</span>
-        <span class="c1">#</span>
-        <span class="c1"># Initially `None`, expects value from the `.run(...)` method.</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">input</span><span class="p">:</span> <span class="n">Any</span> <span class="o">=</span> <span class="kc">None</span>
-
-        <span class="c1"># **output**</span>
-        <span class="c1">#</span>
-        <span class="c1"># Initially `None`. Final value depends on the plugins in the workflow.</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">output</span><span class="p">:</span> <span class="n">Any</span> <span class="o">=</span> <span class="kc">None</span>
 
         <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">preprocessors</span><span class="p">,</span> <span class="nb">list</span><span class="p">):</span>
@@ -284,15 +284,8 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
             <span class="c1"># Type check to ensure postprocessors are lists.</span>
             <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="sa">f</span><span class="s2">"preprocessors=</span><span class="si">{</span><span class="n">postprocessors</span><span class="si">}</span><span class="s2"> should be a list"</span><span class="p">)</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">__postprocessors</span> <span class="o">=</span> <span class="n">postprocessors</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">debug</span> <span class="o">=</span> <span class="n">debug</span>
 
-        <span class="k">if</span> <span class="n">debug</span><span class="p">:</span>
-            <span class="c1"># We have debug logs, which can be opted in but are off by default.</span>
-            <span class="n">change_log_level</span><span class="p">(</span><span class="s2">"DEBUG"</span><span class="p">)</span>
-        <span class="k">else</span><span class="p">:</span>
-            <span class="c1"># Changing log-level to error would mean, logs from log.debug(...) would not appear.</span>
-            <span class="n">change_log_level</span><span class="p">(</span><span class="s2">"ERROR"</span><span class="p">)</span>
-
-    <span class="c1"># == load_model ==</span>
 <div class="viewcode-block" id="Workflow.load_model"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.load_model">[docs]</a>    <span class="k">def</span> <span class="nf">load_model</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Override method in sub-class to load model(s).</span>
@@ -305,8 +298,8 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
             <span class="sa">f</span><span class="s2">"Override method `load_model` in class </span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s2">."</span>
         <span class="p">)</span></div>
 
-    <span class="c1"># == update ==</span>
-<div class="viewcode-block" id="Workflow.update"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.update">[docs]</a>    <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">processor_type</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">processors</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+<div class="viewcode-block" id="Workflow.update"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.update">[docs]</a>    <span class="nd">@dbg</span><span class="p">(</span><span class="n">log</span><span class="p">)</span>
+    <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">processor_type</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">processors</span><span class="p">:</span> <span class="n">List</span><span class="p">[</span><span class="n">PluginFn</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Update input, output attributes.</span>
 
@@ -326,12 +319,31 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
                 <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">processor_type</span><span class="si">}</span><span class="s2">=</span><span class="si">{</span><span class="n">processor</span><span class="si">}</span><span class="s2"> is not a callable"</span><span class="p">)</span>
 
             <span class="c1"># logs are available only when debug=True during class initialization</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">__log</span><span class="p">(</span><span class="s2">"Before"</span><span class="p">,</span> <span class="n">processor_type</span><span class="p">,</span> <span class="n">processor</span><span class="p">)</span>
+            <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span>
+                <span class="n">pformat</span><span class="p">(</span>
+                    <span class="p">{</span>
+                        <span class="s2">"stage"</span><span class="p">:</span> <span class="s2">"Before"</span><span class="p">,</span>
+                        <span class="s2">"type"</span><span class="p">:</span> <span class="n">processor_type</span><span class="p">,</span>
+                        <span class="s2">"plugin"</span><span class="p">:</span> <span class="n">processor</span><span class="p">,</span>
+                        <span class="s2">"input"</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">input</span><span class="p">,</span>
+                        <span class="s2">"output"</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">output</span><span class="p">,</span>
+                    <span class="p">}</span>
+                <span class="p">)</span>
+            <span class="p">)</span>
             <span class="n">processor</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
             <span class="c1"># logs are available only when debug=True during class initialization</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">__log</span><span class="p">(</span><span class="s2">"After"</span><span class="p">,</span> <span class="n">processor_type</span><span class="p">,</span> <span class="n">processor</span><span class="p">)</span></div>
+            <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span>
+                <span class="n">pformat</span><span class="p">(</span>
+                    <span class="p">{</span>
+                        <span class="s2">"stage"</span><span class="p">:</span> <span class="s2">"After"</span><span class="p">,</span>
+                        <span class="s2">"type"</span><span class="p">:</span> <span class="n">processor_type</span><span class="p">,</span>
+                        <span class="s2">"plugin"</span><span class="p">:</span> <span class="n">processor</span><span class="p">,</span>
+                        <span class="s2">"input"</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">input</span><span class="p">,</span>
+                        <span class="s2">"output"</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">output</span><span class="p">,</span>
+                    <span class="p">}</span>
+                <span class="p">)</span>
+            <span class="p">)</span></div>
 
-    <span class="c1"># == preprocess ==</span>
 <div class="viewcode-block" id="Workflow.preprocess"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.preprocess">[docs]</a>    <span class="k">def</span> <span class="nf">preprocess</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Convenience over `update` method.</span>
@@ -340,7 +352,6 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
 <span class="sd">        """</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">constants</span><span class="o">.</span><span class="n">PREPROCESSORS</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">__preprocessors</span><span class="p">)</span></div>
 
-    <span class="c1"># == postprocess ==</span>
 <div class="viewcode-block" id="Workflow.postprocess"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.postprocess">[docs]</a>    <span class="k">def</span> <span class="nf">postprocess</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Convenience over `update` method.</span>
@@ -349,7 +360,6 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
 <span class="sd">        """</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">constants</span><span class="o">.</span><span class="n">POSTPROCESSORS</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">__postprocessors</span><span class="p">)</span></div>
 
-    <span class="c1"># == inference ==</span>
 <div class="viewcode-block" id="Workflow.inference"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.inference">[docs]</a>    <span class="k">def</span> <span class="nf">inference</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
 <span class="sd">        Get model predictions.</span>
@@ -365,9 +375,10 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
                 <span class="sa">f</span><span class="s2">"Override method `inference` in class </span><span class="si">{</span><span class="n">class_name</span><span class="si">}</span><span class="s2">."</span>
             <span class="p">)</span></div>
 
-    <span class="c1"># == run ==</span>
 <div class="viewcode-block" id="Workflow.run"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.run">[docs]</a>    <span class="k">def</span> <span class="nf">run</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">input_</span><span class="p">:</span> <span class="n">Any</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
         <span class="sd">"""</span>
+<span class="sd">        .. _workflow_run:</span>
+
 <span class="sd">        Get final results from the workflow.</span>
 
 <span class="sd">        The current workflow exhibits the following simple procedure:</span>
@@ -386,30 +397,12 @@ <h1>Source code for dialogy.workflow.workflow</h1><div class="highlight"><pre>
         <span class="bp">self</span><span class="o">.</span><span class="n">postprocess</span><span class="p">()</span>
         <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">output</span></div>
 
-    <span class="c1"># == flush ==</span>
 <div class="viewcode-block" id="Workflow.flush"><a class="viewcode-back" href="../../../source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.flush">[docs]</a>    <span class="k">def</span> <span class="nf">flush</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">"""</span>
-<span class="sd">        Reset workflow state.</span>
+<span class="sd">        Reset :code:`workflow.input` and :code:`workflow.output`.</span>
 <span class="sd">        """</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">input</span> <span class="o">=</span> <span class="kc">None</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">output</span> <span class="o">=</span> <span class="kc">None</span></div>
-
-    <span class="c1"># == __log ==</span>
-    <span class="k">def</span> <span class="nf">__log</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">message</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">processor_type</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">processor</span><span class="p">:</span> <span class="n">PluginFn</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
-        <span class="sd">"""</span>
-<span class="sd">        Log the changes in the input/output as pre/post processing functions execute.</span>
-
-<span class="sd">        Args:</span>
-<span class="sd">            message (`str`): One of ["Before", "After"].</span>
-<span class="sd">            processor_type (`str`): One of ["__preprocessor", "__postprocessor"].</span>
-<span class="sd">            processor (`str`): A callable within __preprocessor or __postprocessor.</span>
-<span class="sd">        """</span>
-        <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"</span><span class="si">%s</span><span class="s2"> </span><span class="si">%s</span><span class="s2"> </span><span class="si">%s</span><span class="s2">:"</span><span class="p">,</span> <span class="n">message</span><span class="p">,</span> <span class="n">processor_type</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="n">processor</span><span class="o">.</span><span class="vm">__name__</span><span class="p">)</span>
-        <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"input"</span><span class="p">)</span>
-        <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="n">pformat</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">input</span><span class="p">))</span>
-        <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"output"</span><span class="p">)</span>
-        <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="n">pformat</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">output</span><span class="p">))</span>
-        <span class="n">log</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="s2">"-"</span> <span class="o">*</span> <span class="mi">30</span><span class="p">)</span></div>
+        <span class="bp">self</span><span class="o">.</span><span class="n">output</span> <span class="o">=</span> <span class="kc">None</span></div></div>
 </pre></div>
       </article>
       <footer>
diff --git a/docs/genindex.html b/docs/genindex.html
index 104e52e4..07abb9c6 100644
--- a/docs/genindex.html
+++ b/docs/genindex.html
@@ -203,6 +203,8 @@ <h2>A</h2>
         <li><a href="source/dialogy.postprocess.text.voting.html#dialogy.postprocess.text.voting.intent_voting.adjust_signal_strength">adjust_signal_strength() (in module dialogy.postprocess.text.voting.intent_voting)</a>
 </li>
         <li><a href="source/dialogy.types.intent.html#dialogy.types.intent.Intent.apply">apply() (dialogy.types.intent.Intent method)</a>
+</li>
+        <li><a href="source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.apply_filters">apply_filters() (dialogy.preprocess.text.duckling_plugin.DucklingPlugin method)</a>
 </li>
     </ul></td>
   </tr></table>
@@ -246,6 +248,8 @@ <h2>C</h2>
   <h2>D</h2>
   <table style="width: 100%" class="indextable genindextable"><tr>
     <td style="width: 33%; vertical-align: top;"><ul>
+        <li><a href="source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.DATETIME_OPERATION_ALIAS">DATETIME_OPERATION_ALIAS (dialogy.preprocess.text.duckling_plugin.DucklingPlugin attribute)</a>
+</li>
         <li><a href="source/dialogy.utils.html#dialogy.utils.logger.dbg">dbg() (in module dialogy.utils.logger)</a>
 </li>
         <li>
@@ -597,13 +601,15 @@ <h2>F</h2>
 </li>
         <li><a href="source/dialogy.types.intent.html#dialogy.types.intent.Intent.fill_slot">fill_slot() (dialogy.types.intent.Intent method)</a>
 </li>
-    </ul></td>
-    <td style="width: 33%; vertical-align: top;"><ul>
         <li><a href="source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.flush">flush() (dialogy.workflow.workflow.Workflow method)</a>
 </li>
+    </ul></td>
+    <td style="width: 33%; vertical-align: top;"><ul>
         <li><a href="source/dialogy.constants.html#dialogy.constants.EntityKeys.FROM">FROM (dialogy.constants.EntityKeys attribute)</a>
 </li>
         <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.from_dict">from_dict() (dialogy.types.entity.base_entity.BaseEntity class method)</a>
+</li>
+        <li><a href="source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.FUTURE">FUTURE (dialogy.preprocess.text.duckling_plugin.DucklingPlugin attribute)</a>
 </li>
     </ul></td>
   </tr></table>
@@ -613,18 +619,18 @@ <h2>F</h2>
   <h2>G</h2>
   <table style="width: 100%" class="indextable genindextable"><tr>
     <td style="width: 33%; vertical-align: top;"><ul>
-        <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.get_date_value">get_date_value() (dialogy.types.entity.time_entity.TimeEntity method)</a>
+        <li><a href="source/dialogy.preprocess.text.list_entity_plugin.html#dialogy.preprocess.text.list_entity_plugin.ListEntityPlugin.get_entities">get_entities() (dialogy.preprocess.text.list_entity_plugin.ListEntityPlugin method)</a>
+</li>
+        <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.get_value">get_value() (dialogy.types.entity.base_entity.BaseEntity method)</a>
 
         <ul>
-          <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.get_date_value">(dialogy.types.entity.time_interval_entity.TimeIntervalEntity method)</a>
+          <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.get_value">(dialogy.types.entity.time_entity.TimeEntity method)</a>
+</li>
+          <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.get_value">(dialogy.types.entity.time_interval_entity.TimeIntervalEntity method)</a>
 </li>
         </ul></li>
     </ul></td>
     <td style="width: 33%; vertical-align: top;"><ul>
-        <li><a href="source/dialogy.preprocess.text.list_entity_plugin.html#dialogy.preprocess.text.list_entity_plugin.ListEntityPlugin.get_entities">get_entities() (dialogy.preprocess.text.list_entity_plugin.ListEntityPlugin method)</a>
-</li>
-        <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.get_value">get_value() (dialogy.types.entity.base_entity.BaseEntity method)</a>
-</li>
         <li><a href="source/dialogy.constants.html#dialogy.constants.EntityKeys.GRAIN">GRAIN (dialogy.constants.EntityKeys attribute)</a>
 </li>
     </ul></td>
@@ -836,14 +842,16 @@ <h2>O</h2>
   <h2>P</h2>
   <table style="width: 100%" class="indextable genindextable"><tr>
     <td style="width: 33%; vertical-align: top;"><ul>
+        <li><a href="source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.PAST">PAST (dialogy.preprocess.text.duckling_plugin.DucklingPlugin attribute)</a>
+</li>
         <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.people_entity.PeopleEntity">PeopleEntity (class in dialogy.types.entity.people_entity)</a>
 </li>
         <li><a href="source/dialogy.plugin.html#dialogy.plugin.plugin.Plugin">Plugin (class in dialogy.plugin.plugin)</a>
-</li>
-        <li><a href="source/dialogy.plugin.html#dialogy.plugin.plugin.Plugin.plugin">plugin() (dialogy.plugin.plugin.Plugin method)</a>
 </li>
     </ul></td>
     <td style="width: 33%; vertical-align: top;"><ul>
+        <li><a href="source/dialogy.plugin.html#dialogy.plugin.plugin.Plugin.plugin">plugin() (dialogy.plugin.plugin.Plugin method)</a>
+</li>
         <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.post_init">post_init() (dialogy.types.entity.time_entity.TimeEntity method)</a>
 </li>
         <li><a href="source/dialogy.workflow.html#dialogy.workflow.workflow.Workflow.postprocess">postprocess() (dialogy.workflow.workflow.Workflow method)</a>
@@ -886,6 +894,8 @@ <h2>R</h2>
   <h2>S</h2>
   <table style="width: 100%" class="indextable genindextable"><tr>
     <td style="width: 33%; vertical-align: top;"><ul>
+        <li><a href="source/dialogy.preprocess.text.html#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.select_datetime">select_datetime() (dialogy.preprocess.text.duckling_plugin.DucklingPlugin method)</a>
+</li>
         <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.time_entity.TimeEntity.set_entity_type">set_entity_type() (dialogy.types.entity.time_entity.TimeEntity method)</a>
 </li>
         <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity.set_value">set_value() (dialogy.types.entity.base_entity.BaseEntity method)</a>
@@ -894,10 +904,10 @@ <h2>S</h2>
           <li><a href="source/dialogy.types.entity.html#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.set_value">(dialogy.types.entity.time_interval_entity.TimeIntervalEntity method)</a>
 </li>
         </ul></li>
-        <li><a href="source/dialogy.constants.html#dialogy.constants.SIGNAL">SIGNAL (class in dialogy.constants)</a>
-</li>
     </ul></td>
     <td style="width: 33%; vertical-align: top;"><ul>
+        <li><a href="source/dialogy.constants.html#dialogy.constants.SIGNAL">SIGNAL (class in dialogy.constants)</a>
+</li>
         <li><a href="source/dialogy.types.slots.html#dialogy.types.slots.Slot">Slot (class in dialogy.types.slots)</a>
 </li>
         <li><a href="source/dialogy.constants.html#dialogy.constants.EntityKeys.SLOT_NAMES">SLOT_NAMES (dialogy.constants.EntityKeys attribute)</a>
diff --git a/docs/objects.inv b/docs/objects.inv
index 18c974e8..2bde73ff 100644
Binary files a/docs/objects.inv and b/docs/objects.inv differ
diff --git a/docs/searchindex.js b/docs/searchindex.js
index 7eb1e6f2..e15218f1 100644
--- a/docs/searchindex.js
+++ b/docs/searchindex.js
@@ -1,1 +1,1 @@
-Search.setIndex({docnames:["index","source/dialogy","source/dialogy.cli","source/dialogy.constants","source/dialogy.parser","source/dialogy.parser.text","source/dialogy.parser.text.entity","source/dialogy.plugin","source/dialogy.postprocess","source/dialogy.postprocess.text","source/dialogy.postprocess.text.slot_filler","source/dialogy.postprocess.text.voting","source/dialogy.preprocess","source/dialogy.preprocess.text","source/dialogy.preprocess.text.list_entity_plugin","source/dialogy.types","source/dialogy.types.entity","source/dialogy.types.intent","source/dialogy.types.plugin","source/dialogy.types.signal","source/dialogy.types.slots","source/dialogy.types.utterances","source/dialogy.utils","source/dialogy.workflow","source/modules"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":3,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":2,"sphinx.domains.rst":2,"sphinx.domains.std":2,"sphinx.ext.viewcode":1,sphinx:56},filenames:["index.rst","source/dialogy.rst","source/dialogy.cli.rst","source/dialogy.constants.rst","source/dialogy.parser.rst","source/dialogy.parser.text.rst","source/dialogy.parser.text.entity.rst","source/dialogy.plugin.rst","source/dialogy.postprocess.rst","source/dialogy.postprocess.text.rst","source/dialogy.postprocess.text.slot_filler.rst","source/dialogy.postprocess.text.voting.rst","source/dialogy.preprocess.rst","source/dialogy.preprocess.text.rst","source/dialogy.preprocess.text.list_entity_plugin.rst","source/dialogy.types.rst","source/dialogy.types.entity.rst","source/dialogy.types.intent.rst","source/dialogy.types.plugin.rst","source/dialogy.types.signal.rst","source/dialogy.types.slots.rst","source/dialogy.types.utterances.rst","source/dialogy.utils.rst","source/dialogy.workflow.rst","source/modules.rst"],objects:{"":{dialogy:[1,0,0,"-"]},"dialogy.cli":{main:[2,1,1,""],new_project:[2,1,1,""],project:[2,0,0,"-"]},"dialogy.cli.project":{canonicalize_project_name:[2,1,1,""]},"dialogy.constants":{EntityKeys:[3,2,1,""],SIGNAL:[3,2,1,""]},"dialogy.constants.EntityKeys":{BODY:[3,3,1,""],DIM:[3,3,1,""],DURATION:[3,3,1,""],END:[3,3,1,""],FROM:[3,3,1,""],GRAIN:[3,3,1,""],INTERVAL:[3,3,1,""],LATENT:[3,3,1,""],ORIGIN:[3,3,1,""],RANGE:[3,3,1,""],SLOT_NAMES:[3,3,1,""],START:[3,3,1,""],TO:[3,3,1,""],TYPE:[3,3,1,""],UNIT:[3,3,1,""],VALUE:[3,3,1,""],VALUES:[3,3,1,""]},"dialogy.constants.SIGNAL":{NAME:[3,3,1,""],REPRESENTATION:[3,3,1,""],STRENGTH:[3,3,1,""]},"dialogy.parser":{text:[5,0,0,"-"]},"dialogy.parser.text":{entity:[6,0,0,"-"]},"dialogy.parser.text.entity":{duckling_parser:[6,0,0,"-"]},"dialogy.plugin":{plugin:[7,0,0,"-"]},"dialogy.plugin.plugin":{Plugin:[7,2,1,""]},"dialogy.plugin.plugin.Plugin":{plugin:[7,4,1,""],utility:[7,4,1,""]},"dialogy.postprocess":{text:[9,0,0,"-"]},"dialogy.postprocess.text":{slot_filler:[10,0,0,"-"],voting:[11,0,0,"-"]},"dialogy.postprocess.text.slot_filler":{rule_slot_filler:[10,0,0,"-"]},"dialogy.postprocess.text.slot_filler.rule_slot_filler":{RuleBasedSlotFillerPlugin:[10,2,1,""]},"dialogy.postprocess.text.slot_filler.rule_slot_filler.RuleBasedSlotFillerPlugin":{fill:[10,4,1,""],utility:[10,4,1,""]},"dialogy.postprocess.text.voting":{intent_voting:[11,0,0,"-"]},"dialogy.postprocess.text.voting.intent_voting":{VotePlugin:[11,2,1,""],adjust_signal_strength:[11,1,1,""]},"dialogy.postprocess.text.voting.intent_voting.VotePlugin":{utility:[11,4,1,""],vote_signal:[11,4,1,""]},"dialogy.preprocess":{text:[13,0,0,"-"]},"dialogy.preprocess.text":{duckling_plugin:[13,0,0,"-"],list_entity_plugin:[14,0,0,"-"],merge_asr_output:[13,0,0,"-"],normalize_utterance:[13,0,0,"-"]},"dialogy.preprocess.text.duckling_plugin":{DucklingPlugin:[13,2,1,""]},"dialogy.preprocess.text.duckling_plugin.DucklingPlugin":{utility:[13,4,1,""]},"dialogy.preprocess.text.list_entity_plugin":{ListEntityPlugin:[14,2,1,""]},"dialogy.preprocess.text.list_entity_plugin.ListEntityPlugin":{get_entities:[14,4,1,""],ner_search:[14,4,1,""],regex_search:[14,4,1,""],utility:[14,4,1,""]},"dialogy.preprocess.text.merge_asr_output":{merge_asr_output:[13,1,1,""],merge_asr_output_plugin:[13,1,1,""]},"dialogy.preprocess.text.normalize_utterance":{dict_get:[13,1,1,""],is_each_element:[13,1,1,""],is_list:[13,1,1,""],is_list_of_string:[13,1,1,""],is_string:[13,1,1,""],is_unsqueezed_utterance:[13,1,1,""],is_utterance:[13,1,1,""],normalize:[13,1,1,""]},"dialogy.types":{entity:[16,0,0,"-"],intent:[17,0,0,"-"],plugin:[18,0,0,"-"],signal:[19,0,0,"-"],slots:[20,0,0,"-"],utterances:[21,0,0,"-"]},"dialogy.types.entity":{base_entity:[16,0,0,"-"],duration_entity:[16,0,0,"-"],location_entity:[16,0,0,"-"],numerical_entity:[16,0,0,"-"],people_entity:[16,0,0,"-"],time_entity:[16,0,0,"-"],time_interval_entity:[16,0,0,"-"]},"dialogy.types.entity.base_entity":{BaseEntity:[16,2,1,""],entity_synthesis:[16,1,1,""]},"dialogy.types.entity.base_entity.BaseEntity":{add_parser:[16,4,1,""],copy:[16,4,1,""],entity_type:[16,3,1,""],from_dict:[16,4,1,""],get_value:[16,4,1,""],json:[16,4,1,""],reshape:[16,4,1,""],set_value:[16,4,1,""],validate:[16,4,1,""],value:[16,3,1,""]},"dialogy.types.entity.duration_entity":{DurationEntity:[16,2,1,""]},"dialogy.types.entity.duration_entity.DurationEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.location_entity":{LocationEntity:[16,2,1,""]},"dialogy.types.entity.location_entity.LocationEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.numerical_entity":{NumericalEntity:[16,2,1,""]},"dialogy.types.entity.numerical_entity.NumericalEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.people_entity":{PeopleEntity:[16,2,1,""]},"dialogy.types.entity.people_entity.PeopleEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.time_entity":{TimeEntity:[16,2,1,""]},"dialogy.types.entity.time_entity.TimeEntity":{dim:[16,3,1,""],entity_type:[16,3,1,""],get_date_value:[16,4,1,""],is_uniq_date_from_values:[16,4,1,""],is_uniq_day_from_values:[16,4,1,""],post_init:[16,4,1,""],reshape:[16,4,1,""],set_entity_type:[16,4,1,""],value:[16,3,1,""]},"dialogy.types.entity.time_interval_entity":{TimeIntervalEntity:[16,2,1,""]},"dialogy.types.entity.time_interval_entity.TimeIntervalEntity":{dim:[16,3,1,""],entity_type:[16,3,1,""],get_date_value:[16,4,1,""],origin:[16,3,1,""],reshape:[16,4,1,""],set_value:[16,4,1,""],value:[16,3,1,""]},"dialogy.types.intent":{Intent:[17,2,1,""]},"dialogy.types.intent.Intent":{add_parser:[17,4,1,""],apply:[17,4,1,""],cleanup:[17,4,1,""],fill_slot:[17,4,1,""],json:[17,4,1,""]},"dialogy.types.signal":{signal:[19,0,0,"-"]},"dialogy.types.slots":{Slot:[20,2,1,""]},"dialogy.types.slots.Slot":{add:[20,4,1,""],clear:[20,4,1,""],json:[20,4,1,""]},"dialogy.utils":{logger:[22,0,0,"-"],traverse_dict:[22,1,1,""],validate_type:[22,1,1,""]},"dialogy.utils.logger":{change_log_level:[22,1,1,""],dbg:[22,1,1,""]},"dialogy.workflow":{workflow:[23,0,0,"-"]},"dialogy.workflow.workflow":{Workflow:[23,2,1,""]},"dialogy.workflow.workflow.Workflow":{flush:[23,4,1,""],inference:[23,4,1,""],load_model:[23,4,1,""],postprocess:[23,4,1,""],preprocess:[23,4,1,""],run:[23,4,1,""],update:[23,4,1,""]},dialogy:{cli:[2,0,0,"-"],constants:[3,0,0,"-"],parser:[4,0,0,"-"],plugin:[7,0,0,"-"],postprocess:[8,0,0,"-"],preprocess:[12,0,0,"-"],types:[15,0,0,"-"],utils:[22,0,0,"-"],workflow:[23,0,0,"-"]}},objnames:{"0":["py","module","Python module"],"1":["py","function","Python function"],"2":["py","class","Python class"],"3":["py","attribute","Python attribute"],"4":["py","method","Python method"]},objtypes:{"0":"py:module","1":"py:function","2":"py:class","3":"py:attribute","4":"py:method"},terms:{"000":16,"16t16":16,"17t16":16,"1996":16,"19t00":16,"1st":16,"200":[],"2019":16,"2021":16,"2022":16,"2023":16,"27th":16,"29th":16,"3pm":16,"4pm":16,"556a11057179":22,"5pm":16,"639":13,"6pm":16,"6th":16,"7th":16,"8000":13,"abstract":[7,23],"case":[7,11,13,16,17,23],"class":[0,3,7,10,11,13,14,16,17,20,22,23],"const":[13,16],"default":[2,11,13,16,23],"export":0,"final":23,"float":[11,13,16,17],"function":[2,7,11,13,16,17,22,23],"import":[0,3,10,11,13,16,17,18,20,21,22],"int":[11,14,16,17,22],"long":23,"new":[2,16],"return":[2,11,13,14,16,17,20,22,23],"static":7,"true":[10,11,13,16,17,22,23],"try":22,"while":[7,11,16],For:[],Its:16,LMs:13,Not:10,One:[14,22,23],That:13,The:[2,7,11,13,16,17,22,23],There:[13,14,15,17,22,23],These:[7,13,16,23],Use:[11,16,23],Uses:23,__call__:13,__init__:[2,7,22],__postprocessor:23,__preprocessor:23,__valid:16,_oos_:11,_plugin:7,_what:[],_why:[],abl:13,abort:2,about:[11,13,16],accept:[0,2],access:[7,10,11,13,14,16,18,22,23],across:13,act:15,action:[10,16,17,23],action_slot:10,adapt:13,add:[16,20],add_pars:[16,17],added:16,addit:[7,10],address:[13,16],adjust_signal_strength:11,advanc:23,advantag:1,affect:[0,14],affirm:11,after:[0,16,23],against:23,aggreg:11,aggregate_fn:11,agnost:0,ahead:16,aim:23,air:15,algorithm:11,all:[0,11,13,14,16,20,22],allow:[10,11,14,23],alpha2:13,alreadi:[2,15],also:[13,16],altern:[11,13,21],alternative_index:[10,16,17],analog:22,ani:[2,7,10,11,13,14,16,17,20,22,23],anomali:11,anoth:[14,23],anticip:23,anyth:23,apart:23,api:[7,13],appli:[7,13,16,17,22],applic:[0,23],appropri:[],april:16,arbitrari:[13,16,23],arg:[7,10,11,13,14,16,22,23],arg_nam:22,argument:[11,13,23],arrag:[],arrang:10,artifact:13,asia:13,ask:13,asr:[11,13],assert:22,assist:[10,13],associ:[10,15,17],assum:[7,23],assumpt:0,attempt:11,attribut:[16,17,23],audio:13,avail:[14,16,22],back:22,bad:23,base:[0,3,7,10,11,13,14,16,17,20,23],base_ent:[1,10,13,14,15,17,20],base_entity_prop:3,baseent:[10,13,14,16,17,20,23],batteri:0,becaus:[13,16,23],been:[16,23],beep:22,befor:[13,23],being:[7,11,16,22],best:[11,13],better:7,between:[10,15,16,23],beyond:11,bit:10,bloat:16,block:23,bodi:[3,10,16,17],boilerpl:0,book:16,bool:[7,10,11,13,14,16,17,23],boost:11,booster:11,bop:22,both:16,box:7,briefli:22,build:[0,2,23],built:[7,11],bunch:23,bundl:[14,23],call:[13,16,17,22],callabl:[7,10,11,13,14,16,17,23],can:[0,7,10,11,13,14,15,16,17,20,23],candid:[11,14],cannot:[],canonicalize_project_nam:2,care:23,categori:10,caution:[11,13,16],certain:[10,13],challeng:7,chanc:13,chang:[7,16,22,23],change_log_level:22,charset:[],check:[10,13,16,17,22,23],children:16,choic:[0,23],classifi:[10,11,23],classmethod:16,cleanup:17,clear:20,cli:[0,1,24],closur:[],cls:16,code:[0,13],collat:23,collect:[0,16],com:[10,13],combin:[],command:2,commit:2,common:13,compat:[],compli:16,complianc:16,compon:0,comput:23,concat:13,concaten:[11,13],conceal:16,concept:23,condit:[22,23],conduit:23,confid:11,configur:[10,13,14,17,22],connect:13,connectionerror:[],consensu:11,consid:[11,15],consider:[11,23],consist:13,constant:[0,1,24],constitu:11,constraint:23,contain:[10,11,16,17],content:24,context:7,contextu:11,continu:11,conveni:[7,23],convent:7,convers:15,convert:[16,17,20],copi:[2,16],copier:2,core:23,corpu:7,corpus_dir:7,corpus_fil:7,correspond:[],cost:13,could:[11,16,23],count:11,count_peopl:10,counterpart:11,countri:13,coupl:[16,23],cover:[13,16],creat:[0,2,7,10,13,16,17],critic:22,currenc:13,current:[2,10,14,16,20,23],custom:7,customplugin:7,cuz:13,dai:16,dampen:11,data:[2,13,16],databas:13,dataset:2,date:[13,15,16],datetim:16,dbg:22,debug:[7,10,11,13,14,16,17,22,23],decemb:16,decid:11,decis:[],decor:22,deep:16,deepli:22,def:[7,11,13],defin:[10,11,13,16,18,23],definit:[13,17,20],deliber:[],demo:[17,23],denot:16,depend:[16,23],depict:11,deploi:13,deprec:6,deriv:[],describ:22,design:[7,10,11,23],desir:23,destin:15,destination_path:2,detail:[0,13,17],develop:13,dialog:10,dict:[10,13,14,16,17,20,22],dict_:16,dict_get:13,dict_travers:22,dictionari:[16,17,20,22],did:[11,16],didn:16,differ:[7,11,13,14,16,17],dim:[3,10,16],dimens:[13,16],dimension_entity_map:[],dir:2,directli:[7,23],directori:2,dissimilar:13,doc:[],document:13,doe:10,doesn:[13,16,22],don:[7,22],done:13,down:13,downstream:13,drop:23,duckl:[13,14,16],duckling_ent:13,duckling_pars:[4,5,13],duckling_plugin:[1,12],duckling_time_ent:16,ducklingpars:6,ducklingplug:6,ducklingplugin:[0,6,7,13,14,23],due:22,durat:[3,13,16],duration_ent:[1,15],durationent:16,dynam:7,each:[10,11,13,14,16],easi:0,either:[2,15,16,22],elect:11,element:[10,13,16,22,23],elimin:[],els:[11,13,16],emit:11,en_gb:13,en_in:13,en_u:13,encourag:7,end:[3,7,10,13,16],enforc:23,english:10,entiti:[0,1,4,5,10,13,14,15,17,20,22,23],entities_json:[],entity_map:[13,14],entity_nam:[],entity_synthesi:16,entity_typ:[10,16],entityclass:14,entitykei:3,environ:[],error:22,especi:13,etc:[13,16,23],evalu:11,even:[7,10],everi:23,everyth:13,evid:11,exampl:[2,7,10,13,15,16],except:22,exclus:22,execut:[22,23],exhibit:[2,23],exist:[2,7,13,22],expect:[7,10,11,13,14,15,16,23],experi:13,explicit:16,explicitli:16,explor:17,expos:[2,7,13],express:13,extend:7,extern:7,extra:13,extract:[10,13,14,20],facebook:[],facilit:13,fact:13,fail:[11,13],fairli:23,fallback:11,fallback_int:11,fals:[7,10,11,13,14,16,17,23],faq:10,featur:7,few:[0,7,10,14,15,23],field:13,file:2,file_path:7,fill:[10,15,17,20,23],fill_multipl:[10,17],fill_slot:17,filler:10,filter:[11,16,23],find:11,fine:13,first:22,fix:16,flag:14,flatten:13,flavor:16,flexibl:23,flight:16,flush:23,focu:0,follow:23,food:[],foreign:23,forest:11,fork:13,form:13,format:[10,13,16],found:10,framework:0,free:[7,13],frequenc:11,from:[2,3,7,10,11,13,14,16,17,22,23],from_dict:[14,16],gap:11,gener:[2,11,15],geographi:13,geopointent:16,get:[0,10,13,16,23],get_date_valu:16,get_ent:14,get_valu:16,getworkflowutterancefn:[13,18],git:2,github:13,gitlab:[],given:[13,16,22],goal:[],goe:11,grain:[3,16],graviti:23,great:13,ground:23,group:11,guid:13,hack:14,had:11,hamper:7,handl:[7,10,11,13,16,23],hang:23,has:[7,11,16,17],have:[0,10,11,13,16,17,22,23],head:2,header:[],healthi:11,hello:[2,13],help:[0,2,7,11,13,16,17],here:[2,7,11,13,16,23],heurist:11,high:11,hold:17,hollow:23,hope:[7,13],hour:16,how:11,html:10,http:[10,13],ideal:[7,11,23],ident:13,identifi:[10,16,17],ids:[13,16],impact:[13,14],imper:13,implement:[7,13,16,23],impli:[11,13],improv:[7,11,13],includ:[0,16],inconsequenti:13,index:[0,22],indexerror:[16,22],individu:14,infer:[16,23],info:[13,22],inform:[11,13,16,19],initi:[],inner:23,input:[7,10,11,13,16,22,23],input_:[7,10,11,13,22,23],insert:[7,14,20],instal:2,instanc:[7,11,13,16,17,20,22],instanti:[10,13,16],instead:[6,13,22],intend:16,intent:[0,1,10,11,15,23],intent_detection_slot_fil:10,intent_nam:10,intent_vot:[8,9],interact:[0,7,23],interfac:13,intermedi:[11,14],interv:[3,16],invoc:2,invok:13,involv:14,ipython:22,irrespect:10,is_each_el:13,is_list:13,is_list_of_str:13,is_str:13,is_uniq_date_from_valu:16,is_uniq_day_from_valu:16,is_unsqueezed_utter:13,is_utter:13,isn:[13,23],iso3166:13,iso:[13,16],isol:7,issu:[13,16],item:10,iter:23,its:[7,10,11,13,16,17],join:[7,13],json:[16,17,20,23],judg:23,juli:16,just:[7,13,14],keep:[7,14],kei:[7,13,14,16,20],key_error:22,keyerror:[16,22],know:[13,23],known:16,kolkata:13,kwarg:22,label:14,lambda:[10,11,13,22],lambdax:[],languag:[13,22,23],largest:23,last:[16,22],latent:[3,10,16],latest:2,latitud:16,lead:[11,22],learn:[0,11,23],leav:13,len:11,let:[0,10,11],level:[22,23],lib:13,librari:0,light:23,like:[7,10,11,13,15,16],line:[2,13],link:2,lint:2,list:[10,11,13,14,16,17,20,22,23],list_entity_plugin:[0,12,13],listentityplugin:14,littl:23,load:[7,23],load_corpu:7,load_model:23,local:[2,13],locat:[2,16],location_ent:[1,15],locationent:[10,16],log:[11,22,23],logger:[1,24],logic:22,longitud:16,look:[10,11,13,23],low:[],machin:[0,23],made:[0,7,11],mai:[10,13,23],main:2,make:[0,2,13,16,22,23],makeplugin:[],manag:23,mani:[11,23],manner:16,map:[10,14],mar:22,mark:13,mastercard:13,match:[10,13,14,16,22],matchtyp:14,mayb:17,maybe_utter:13,mean:[11,13,15,17],meant:16,medium:23,mention:16,merg:13,merge_asr_output:[0,1,12],merge_asr_output_plugin:[7,13],met:[7,11],meta:16,method:[7,10,13,14,16,22,23],metric:2,minim:0,minut:16,mismatch:22,miss:[2,13,22],mock:[11,23],model:[2,10,11,13,14,23],modif:[7,16,17],modifi:[11,17,23],modul:[0,24],mondai:16,month:16,more:[10,11,13,16,23],morn:16,most:[13,22],multipl:[11,13,17],must:[2,7,22],mutat:[7,10,11,13,14,16,23],mutate_ent:[],naiv:11,name:[2,3,7,10,11,13,16,17,20,22,23],namespac:2,navig:22,nearbi:[],neatli:23,necessari:16,need:[10,11,13,14,16,22,23],neg:[11,16],neither:22,ner:14,ner_search:14,nest:22,new_project:2,night:16,nlp:13,nlpprogress:10,nois:13,non:13,none:[2,7,10,11,13,14,16,17,22,23],nonetyp:2,normal:[10,11,13,16],normalize_utter:[1,12],note:13,noth:[11,16],notic:[10,11,13],notimplementederror:23,now:11,number:[10,11,13,15,16,23],number_ent:10,number_slot:10,numer:[13,16],numerical_ent:[1,15],numericalent:[10,16],obj:[13,22],obj_typ:22,object:[3,7,13,16,17,20,22,23],observ:11,obtain:[11,16],occurr:11,oct:16,octob:16,odd:[],offer:[7,23],onc:[7,10,13],one:[10,11,13,15,16],ones:23,onli:[10,11,13,14,16,22],open:[7,16],oper:[13,16],opinion:0,oppos:14,option:[2,7,10,11,13,14,16,17,23],order:[],organ:2,origin:[3,10,15,16],other:[0,10,11,14,16,23],out:[10,11,13,16,17,22],output:[7,10,11,13,23],over:[11,14,23],overal:[11,13],overrid:[16,23],overridden:[16,23],owing:13,own:16,packag:[0,24],paint:11,param:22,paramet:[2,10,11,13,14,16,17,22,23],park:16,pars:[13,14,16,22],parser:[0,1,10,13,16,17,24],part:[13,16],parti:7,partial:13,particip:15,pass:[10,11,13,16,22,23],passeng:15,path:[7,22,23],pattern:[13,14],peopl:[7,10,13,16],people_ent:[1,10,15],people_entity_prop:3,peopleent:[10,16],per:[7,10,13],percentag:11,perform:13,pertain:10,pick:11,pictur:11,pinpoint:16,pip:0,pipe:23,pipelin:[7,23],place:[7,11,13,23],plain:11,planet:22,pleas:6,plugin:[0,1,10,11,13,14,15,16,17,23,24],pluginfn:[7,10,11,14,16,17,18,23],poetri:2,point:[2,7,11],poor:11,popular:0,portabl:[7,23],posit:[13,16],possibl:[16,17,22],post:[7,23],post_init:16,postprocess:[0,1,16,17,23,24],postprocessor:[0,3,10,11,16,17,23],pprint:10,practic:10,pre:[7,10,18,23],preceed:[],precis:13,predict:[11,23],prefer:[17,22],preprocess:[0,1,23,24],preprocessor:[0,3,10,11,13,23],present:10,preset:10,prevent:[13,14,16],previou:16,priorit:[],pristin:14,privat:13,problem:[0,13],procedur:23,process:[7,13,23],processor:23,processor_typ:23,produc:[11,13],product:[11,16,17],progress:[0,15,16,17],project:[1,3,15,22,23,24],prop:13,properti:[13,16,22],property_:16,proport:11,provid:[3,7,10,11,13,16,18,19,21,22],proxi:23,purpos:16,put:23,python:22,pytz:13,quarter:16,queri:[],rais:[11,13,16,22,23],rang:[3,10,16,22],rank:11,rather:[],reach:13,read:[7,13],readi:[0,11],readthedoc:[],recal:13,receiv:[11,23],recent:22,recurs:22,reduc:[11,22],refactor:14,refer:[2,13,16],reference_tim:[],reftim:13,regex:14,regex_search:14,rel:[],relai:23,relat:[10,13],relationship:[10,15],releas:2,remain:11,remov:[17,20],replac:16,report:10,repres:[10,13],represent:[3,11,16],request:[],requir:[7,13,14,15,23],reserv:15,reset:23,reshap:16,resid:13,resort:11,respect:[13,15,16],respons:13,restaur:[],restrict:[7,22,23],result:23,retriev:[],review:0,root:2,round:15,rtype:[16,22],rule:[10,17],rule_slot_fil:[8,9],rule_str:10,rulebasedslotfillerplugin:[0,7,10,17,23],ruleslotfil:[],ruleslotfilerplugin:7,run:[7,10,11,13,22,23],runtim:7,safe:[7,11,16],safe_load:10,safeguard:23,safest:11,sai:[11,16,23],said:16,same:[7,14,17],saturdai:16,sauci:23,scaffold:[0,2],schema:10,score:[10,11,16,17],screen:2,search:[13,14],searchstrategyclass:14,second:16,section:[13,15,16],see:23,self:[7,16],semant:13,sentenc:[13,15,16],sentence2vecplugin:7,separ:[7,13],server:13,servic:[13,14],session:0,set:[7,10,11,13,14,15,16,17,22],set_entity_typ:16,set_valu:16,shall:10,shape:14,share:17,shift:23,ship:[7,13,14],should:[11,13,16,17,23],show:[2,14],sic:23,signal:[0,1,3,11,15],signatur:[10,23],signific:[10,13,15],similar:[11,13,23],simpl:[0,2,7,13,23],simpli:13,simplifi:[],simul:11,sinc:[6,7,11,13,16],singl:[10,11,13,17],situat:11,size:11,skip:16,skip_entity_attr:16,slot:[0,1,10,11,15,17,23],slot_fil:[0,8,9],slot_nam:[3,10,16],slot_rul:10,slot_typ:17,slotfil:[],slow:13,slu:[0,11,15,23],smallest:16,solut:[0,7],some:[7,11,13,16,23],somewher:13,sort:23,sourc:[2,3,7,10,11,13,14,16,17,20,22,23],spaci:14,spacy_nlp:14,sparingli:22,speaker:22,special:17,specif:[13,16,22],specifi:[2,7,13],speech:0,splitlin:7,stabl:[],stack:0,stage:7,stall:13,standard:13,start:[2,3,10,13,16],state:[11,13],statist:23,statu:[],store:16,str:[2,7,10,11,13,14,16,17,20,22,23],strategi:[13,14],strength:[3,11],string:[11,13,14,16],strong:11,stronger:23,structur:[1,7,13,14,16],style:14,sub:[0,23],subclass:[13,16,23],submodul:[1,4,5,8,9,12,15,24],subpackag:24,sugar:[16,22],summar:7,summari:[],sundai:16,supplier:23,support:[2,13,16,17,23],suppos:[16,23],sure:13,syntat:22,synthet:10,system:[10,13],tag:2,tailor:7,take:[2,11,23],target:[],task:[13,23],tell:[10,11,15,16],templat:[0,2],tend:13,termin:13,test:[],test_duckling_pars:[],test_ent:[],test_merge_asr_output:[],test_plugin:[],test_rule_slot_fil:[],test_workflow:[],text:[0,1,4,8,12,17],than:[10,11],thei:[13,16,23],them:[7,10,13,22],therefor:[7,16],thi:[2,7,10,11,13,14,15,16,17,19,20,22,23],think:23,third:[7,10],those:[13,16,22,23],though:13,threshold:11,through:[10,13,16,23],throughout:[7,22],throughtout:3,thu:[],thud:23,ticket:15,till:16,time:[10,13,14,15,16,22],time_ent:[1,15],time_entity_prop:3,time_interval_ent:[1,15],time_slot:10,timeent:[10,16],timeinterv:13,timeintervalent:16,timeout:13,timestamp:16,timezon:13,todai:16,togeth:16,token:[10,11,15,16],tomorrow:16,tonight:16,tool:14,top:11,total:11,traceback:22,train:[],transcript:[11,13,14],transform:[0,2,13],travel:15,travers:22,traverse_dict:22,tree:11,trial:11,trip:15,triplet:16,tupl:[2,10,11,14,22],tutori:[],two:[10,11,16,22,23],type:[0,1,2,3,10,11,13,14,22,23,24],type_:13,typeerror:[11,13,22,23],umm:13,unawar:7,under:[11,13],undergo:22,understand:17,union:[13,22],uniqu:[11,13,16],unit:[3,10,16],unk:11,unless:10,unsaf:[11,16],unset:13,updat:[7,16,17,22,23],update_int:11,update_workflow:13,updateworkflowstringfn:[13,18],upon:15,upto:[],url:13,urlencod:[],usabl:[],usag:[2,7],use:[0,2,6,7,10,13,15,23],used:[3,13,16,22,23],useful:[7,22],user:[2,16],usernam:[],uses:2,using:[0,2,11,13,14,16,17,22,23],usual:7,utf:[],util:[0,1,2,7,10,11,13,14,16,17,24],utter:[0,1,13,15,16],valid:[13,16],validate_typ:22,valu:[3,7,10,11,13,14,16,17,20,22,23],valueerror:[],variant:16,variou:[7,13],vcs:2,vcs_ref:2,vector:13,veri:[11,13,23],verifi:16,vernacular:[2,13],version:[2,6,23],vertic:23,via:[7,14,22],vote:[0,8,9],vote_plugin:11,vote_sign:11,voteintentplugin:11,voteplugin:[0,7,11,13,23],wai:[7,11,15,22],want:[13,16,17,23],warn:22,weak:11,week:16,weekdai:16,weight:11,well:[13,16,23],went:16,were:[13,16,17,23],when:13,where:[2,11,13,16,17,23],which:[11,13,14,16,17,23],whole:16,why:23,win:11,wish:16,within:[13,14,15,16,17,20,22,23],without:[22,23],won:[7,23],words2num_plugin:7,work:[13,15,23],workflow:[0,1,7,10,11,13,14,24],workflow_public_properti:3,world:[2,13],worri:23,worst:11,would:[13,15,23],wrap:22,wrapper:14,write:[0,7],written:7,www:[],yaml:10,year:16,yep:11,yes:[11,23],yesterdai:16,yet:11,yield:11,you:[0,10,13,15,23],your:[0,23],your_project_nam:0},titles:["Dialogy","dialogy package","dialogy.cli package","dialogy.constants package","dialogy.parser package","dialogy.parser.text package","dialogy.parser.text.entity package","dialogy.plugin package","dialogy.postprocess package","dialogy.postprocess.text package","dialogy.postprocess.text.slot_filler package","dialogy.postprocess.text.voting package","dialogy.preprocess package","dialogy.preprocess.text package","dialogy.preprocess.text.list_entity_plugin package","dialogy.types package","dialogy.types.entity package","dialogy.types.intent package","dialogy.types.plugin package","dialogy.types.signal package","dialogy.types.slots package","dialogy.types.utterances package","dialogy.utils package","dialogy.workflow package","dialogy"],titleterms:{advantag:23,base_ent:16,cli:2,constant:3,content:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],dialogi:[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24],duckling_pars:6,duckling_plugin:13,duration_ent:16,entiti:[6,16],faq:0,instal:0,intent:17,intent_vot:11,list_entity_plugin:14,location_ent:16,logger:22,merge_asr_output:13,modul:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],normalize_utter:13,numerical_ent:16,packag:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],parser:[4,5,6],people_ent:16,plugin:[7,18],postprocess:[8,9,10,11],preprocess:[12,13,14],project:[0,2],rule_slot_fil:10,section:0,signal:19,slot:20,slot_fil:10,start:0,structur:23,submodul:[2,6,7,10,11,13,16,19,22,23],subpackag:[1,4,5,8,9,12,13,15],test:0,text:[5,6,9,10,11,13,14],time_ent:16,time_interval_ent:16,type:[15,16,17,18,19,20,21],util:22,utter:21,vote:11,workflow:23}})
\ No newline at end of file
+Search.setIndex({docnames:["index","source/dialogy","source/dialogy.cli","source/dialogy.constants","source/dialogy.parser","source/dialogy.parser.text","source/dialogy.parser.text.entity","source/dialogy.plugin","source/dialogy.postprocess","source/dialogy.postprocess.text","source/dialogy.postprocess.text.slot_filler","source/dialogy.postprocess.text.voting","source/dialogy.preprocess","source/dialogy.preprocess.text","source/dialogy.preprocess.text.list_entity_plugin","source/dialogy.types","source/dialogy.types.entity","source/dialogy.types.intent","source/dialogy.types.plugin","source/dialogy.types.signal","source/dialogy.types.slots","source/dialogy.types.utterances","source/dialogy.utils","source/dialogy.workflow","source/modules"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":3,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":2,"sphinx.domains.rst":2,"sphinx.domains.std":2,"sphinx.ext.viewcode":1,sphinx:56},filenames:["index.rst","source/dialogy.rst","source/dialogy.cli.rst","source/dialogy.constants.rst","source/dialogy.parser.rst","source/dialogy.parser.text.rst","source/dialogy.parser.text.entity.rst","source/dialogy.plugin.rst","source/dialogy.postprocess.rst","source/dialogy.postprocess.text.rst","source/dialogy.postprocess.text.slot_filler.rst","source/dialogy.postprocess.text.voting.rst","source/dialogy.preprocess.rst","source/dialogy.preprocess.text.rst","source/dialogy.preprocess.text.list_entity_plugin.rst","source/dialogy.types.rst","source/dialogy.types.entity.rst","source/dialogy.types.intent.rst","source/dialogy.types.plugin.rst","source/dialogy.types.signal.rst","source/dialogy.types.slots.rst","source/dialogy.types.utterances.rst","source/dialogy.utils.rst","source/dialogy.workflow.rst","source/modules.rst"],objects:{"":{dialogy:[1,0,0,"-"]},"dialogy.cli":{main:[2,1,1,""],new_project:[2,1,1,""],project:[2,0,0,"-"]},"dialogy.cli.project":{canonicalize_project_name:[2,1,1,""]},"dialogy.constants":{EntityKeys:[3,2,1,""],SIGNAL:[3,2,1,""]},"dialogy.constants.EntityKeys":{BODY:[3,3,1,""],DIM:[3,3,1,""],DURATION:[3,3,1,""],END:[3,3,1,""],FROM:[3,3,1,""],GRAIN:[3,3,1,""],INTERVAL:[3,3,1,""],LATENT:[3,3,1,""],ORIGIN:[3,3,1,""],RANGE:[3,3,1,""],SLOT_NAMES:[3,3,1,""],START:[3,3,1,""],TO:[3,3,1,""],TYPE:[3,3,1,""],UNIT:[3,3,1,""],VALUE:[3,3,1,""],VALUES:[3,3,1,""]},"dialogy.constants.SIGNAL":{NAME:[3,3,1,""],REPRESENTATION:[3,3,1,""],STRENGTH:[3,3,1,""]},"dialogy.parser":{text:[5,0,0,"-"]},"dialogy.parser.text":{entity:[6,0,0,"-"]},"dialogy.parser.text.entity":{duckling_parser:[6,0,0,"-"]},"dialogy.plugin":{plugin:[7,0,0,"-"]},"dialogy.plugin.plugin":{Plugin:[7,2,1,""]},"dialogy.plugin.plugin.Plugin":{plugin:[7,4,1,""],utility:[7,4,1,""]},"dialogy.postprocess":{text:[9,0,0,"-"]},"dialogy.postprocess.text":{slot_filler:[10,0,0,"-"],voting:[11,0,0,"-"]},"dialogy.postprocess.text.slot_filler":{rule_slot_filler:[10,0,0,"-"]},"dialogy.postprocess.text.slot_filler.rule_slot_filler":{RuleBasedSlotFillerPlugin:[10,2,1,""]},"dialogy.postprocess.text.slot_filler.rule_slot_filler.RuleBasedSlotFillerPlugin":{fill:[10,4,1,""],utility:[10,4,1,""]},"dialogy.postprocess.text.voting":{intent_voting:[11,0,0,"-"]},"dialogy.postprocess.text.voting.intent_voting":{VotePlugin:[11,2,1,""],adjust_signal_strength:[11,1,1,""]},"dialogy.postprocess.text.voting.intent_voting.VotePlugin":{utility:[11,4,1,""],vote_signal:[11,4,1,""]},"dialogy.preprocess":{text:[13,0,0,"-"]},"dialogy.preprocess.text":{duckling_plugin:[13,0,0,"-"],list_entity_plugin:[14,0,0,"-"],merge_asr_output:[13,0,0,"-"],normalize_utterance:[13,0,0,"-"]},"dialogy.preprocess.text.duckling_plugin":{DucklingPlugin:[13,2,1,""]},"dialogy.preprocess.text.duckling_plugin.DucklingPlugin":{DATETIME_OPERATION_ALIAS:[13,3,1,""],FUTURE:[13,3,1,""],PAST:[13,3,1,""],apply_filters:[13,4,1,""],select_datetime:[13,4,1,""],utility:[13,4,1,""]},"dialogy.preprocess.text.list_entity_plugin":{ListEntityPlugin:[14,2,1,""]},"dialogy.preprocess.text.list_entity_plugin.ListEntityPlugin":{get_entities:[14,4,1,""],ner_search:[14,4,1,""],regex_search:[14,4,1,""],utility:[14,4,1,""]},"dialogy.preprocess.text.merge_asr_output":{merge_asr_output:[13,1,1,""],merge_asr_output_plugin:[13,1,1,""]},"dialogy.preprocess.text.normalize_utterance":{dict_get:[13,1,1,""],is_each_element:[13,1,1,""],is_list:[13,1,1,""],is_list_of_string:[13,1,1,""],is_string:[13,1,1,""],is_unsqueezed_utterance:[13,1,1,""],is_utterance:[13,1,1,""],normalize:[13,1,1,""]},"dialogy.types":{entity:[16,0,0,"-"],intent:[17,0,0,"-"],plugin:[18,0,0,"-"],signal:[19,0,0,"-"],slots:[20,0,0,"-"],utterances:[21,0,0,"-"]},"dialogy.types.entity":{base_entity:[16,0,0,"-"],duration_entity:[16,0,0,"-"],location_entity:[16,0,0,"-"],numerical_entity:[16,0,0,"-"],people_entity:[16,0,0,"-"],time_entity:[16,0,0,"-"],time_interval_entity:[16,0,0,"-"]},"dialogy.types.entity.base_entity":{BaseEntity:[16,2,1,""],entity_synthesis:[16,1,1,""]},"dialogy.types.entity.base_entity.BaseEntity":{add_parser:[16,4,1,""],copy:[16,4,1,""],entity_type:[16,3,1,""],from_dict:[16,4,1,""],get_value:[16,4,1,""],json:[16,4,1,""],reshape:[16,4,1,""],set_value:[16,4,1,""],validate:[16,4,1,""],value:[16,3,1,""]},"dialogy.types.entity.duration_entity":{DurationEntity:[16,2,1,""]},"dialogy.types.entity.duration_entity.DurationEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.location_entity":{LocationEntity:[16,2,1,""]},"dialogy.types.entity.location_entity.LocationEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.numerical_entity":{NumericalEntity:[16,2,1,""]},"dialogy.types.entity.numerical_entity.NumericalEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.people_entity":{PeopleEntity:[16,2,1,""]},"dialogy.types.entity.people_entity.PeopleEntity":{entity_type:[16,3,1,""],value:[16,3,1,""]},"dialogy.types.entity.time_entity":{TimeEntity:[16,2,1,""]},"dialogy.types.entity.time_entity.TimeEntity":{dim:[16,3,1,""],entity_type:[16,3,1,""],get_value:[16,4,1,""],is_uniq_date_from_values:[16,4,1,""],is_uniq_day_from_values:[16,4,1,""],post_init:[16,4,1,""],reshape:[16,4,1,""],set_entity_type:[16,4,1,""],value:[16,3,1,""]},"dialogy.types.entity.time_interval_entity":{TimeIntervalEntity:[16,2,1,""]},"dialogy.types.entity.time_interval_entity.TimeIntervalEntity":{dim:[16,3,1,""],entity_type:[16,3,1,""],get_value:[16,4,1,""],origin:[16,3,1,""],reshape:[16,4,1,""],set_value:[16,4,1,""],value:[16,3,1,""]},"dialogy.types.intent":{Intent:[17,2,1,""]},"dialogy.types.intent.Intent":{add_parser:[17,4,1,""],apply:[17,4,1,""],cleanup:[17,4,1,""],fill_slot:[17,4,1,""],json:[17,4,1,""]},"dialogy.types.signal":{signal:[19,0,0,"-"]},"dialogy.types.slots":{Slot:[20,2,1,""]},"dialogy.types.slots.Slot":{add:[20,4,1,""],clear:[20,4,1,""],json:[20,4,1,""]},"dialogy.utils":{logger:[22,0,0,"-"],traverse_dict:[22,1,1,""],validate_type:[22,1,1,""]},"dialogy.utils.logger":{change_log_level:[22,1,1,""],dbg:[22,1,1,""]},"dialogy.workflow":{workflow:[23,0,0,"-"]},"dialogy.workflow.workflow":{Workflow:[23,2,1,""]},"dialogy.workflow.workflow.Workflow":{flush:[23,4,1,""],inference:[23,4,1,""],load_model:[23,4,1,""],postprocess:[23,4,1,""],preprocess:[23,4,1,""],run:[23,4,1,""],update:[23,4,1,""]},dialogy:{cli:[2,0,0,"-"],constants:[3,0,0,"-"],parser:[4,0,0,"-"],plugin:[7,0,0,"-"],postprocess:[8,0,0,"-"],preprocess:[12,0,0,"-"],types:[15,0,0,"-"],utils:[22,0,0,"-"],workflow:[23,0,0,"-"]}},objnames:{"0":["py","module","Python module"],"1":["py","function","Python function"],"2":["py","class","Python class"],"3":["py","attribute","Python attribute"],"4":["py","method","Python method"]},objtypes:{"0":"py:module","1":"py:function","2":"py:class","3":"py:attribute","4":"py:method"},terms:{"000":16,"16t16":16,"17t16":16,"1996":16,"19t00":16,"1st":16,"200":[],"2019":16,"2021":16,"2022":16,"2023":16,"27th":16,"29th":16,"3pm":16,"4pm":16,"556a11057179":22,"5pm":16,"639":13,"6pm":16,"6th":16,"7th":16,"8000":13,"abstract":[7,23],"case":[7,11,13,16,17,23],"class":[0,3,7,10,11,13,14,16,17,20,22,23],"const":[13,16],"default":[2,11,13,16,23],"export":0,"final":23,"float":[11,13,16,17],"function":[2,7,11,13,16,17,22,23],"import":[0,3,10,11,13,16,17,18,20,21,22],"int":[11,13,14,16,17,22],"long":23,"new":[2,16],"return":[2,11,13,14,16,17,20,22,23],"static":7,"true":[10,11,13,16,17,22,23],"try":22,"while":[7,11,16],For:[],Its:16,LMs:13,Not:10,One:[14,22,23],That:13,The:[2,7,11,13,16,17,22,23],There:[13,14,15,17,22,23],These:[7,13,16,23],Use:[11,16,23],Uses:23,__call__:13,__init__:[2,7,22],__postprocessor:23,__preprocessor:23,__valid:16,_oos_:11,_plugin:7,_what:[],_why:[],abl:13,abort:2,about:[11,13,16],accept:[0,2],access:[7,10,11,13,14,16,18,22,23],across:13,act:15,action:[10,16,17,23],action_slot:10,adapt:13,add:[16,20],add_pars:[16,17],added:16,addit:[7,10],address:[13,16],adjust_signal_strength:11,advanc:23,advantag:1,advent:13,affect:[0,14],affirm:11,after:[0,13,16,23],against:23,aggreg:11,aggregate_fn:11,agnost:0,ahead:16,aim:23,air:15,algorithm:11,all:[0,11,13,14,16,20,22],allow:[10,11,14,23],alpha2:13,alreadi:[2,15],also:[13,16],altern:[11,13,21],alternative_index:[10,16,17],analog:22,ani:[2,7,10,11,13,14,16,17,20,22,23],anomali:11,anoth:[14,23],anticip:23,anyth:23,apart:23,api:[7,13],appli:[7,13,16,17,22],applic:[0,13,23],apply_filt:13,appropri:[],april:16,arbitrari:[13,16,23],arg:[7,10,11,13,14,16,22,23],arg_nam:22,argument:[11,13,23],arrag:[],arrang:10,artifact:13,asia:13,ask:13,asr:[11,13],assert:22,assist:[10,13],associ:[10,15,17],assum:[7,23],assumpt:0,attempt:11,attribut:[13,16,17,23],audio:13,avail:[14,16,22],back:22,bad:23,base:[0,3,7,10,11,13,14,16,17,20,23],base_ent:[1,10,13,14,15,17,20],base_entity_prop:3,baseent:[10,13,14,16,17,20,23],batteri:0,becaus:[13,16,23],been:[16,23],beep:22,befor:[13,23],being:[7,11,16,22],best:[11,13],better:7,between:[10,15,16,23],beyond:11,bit:10,bloat:16,block:23,bodi:[3,10,16,17],boilerpl:0,book:16,bool:[7,10,11,13,14,16,17,23],boost:11,booster:11,bop:22,both:16,box:7,briefli:22,build:[0,2,23],built:[7,11,13],bunch:23,bundl:[14,23],call:[13,16,17,22],callabl:[7,10,11,13,14,16,17,23],can:[0,7,10,11,13,14,15,16,17,20,23],candid:[11,14],cannot:[],canonicalize_project_nam:2,care:23,categori:10,caution:[11,13,16],certain:[10,13],challeng:7,chanc:13,chang:[7,16,22,23],change_log_level:22,charset:[],check:[10,13,16,17,22,23],children:16,choic:[0,23],classifi:[10,11,23],classmethod:16,cleanup:17,clear:20,cli:[0,1,24],closur:[],cls:16,code:[0,13],collat:23,collect:[0,16],com:[10,13],combin:[],command:2,commit:2,common:13,compar:13,compat:[],compli:16,complianc:16,compon:0,comput:23,concat:13,concaten:[11,13],conceal:16,concept:23,condit:[22,23],conduit:23,confid:11,configur:[10,13,14,17,22],connect:13,connectionerror:[],consensu:11,consid:[11,15],consider:[11,23],consist:13,constant:[0,1,24],constitu:11,constraint:23,contain:[10,11,16,17],content:24,context:7,contextu:11,continu:11,conveni:[7,23],convent:7,convers:15,convert:[16,17,20],copi:[2,16],copier:2,core:23,corpu:7,corpus_dir:7,corpus_fil:7,correspond:[],cost:13,could:[11,16,23],count:11,count_peopl:10,counterpart:11,countri:13,coupl:[16,23],cover:[13,16],creat:[0,2,7,10,13,16,17],criteria:13,critic:22,currenc:13,current:[2,10,14,16,20,23],custom:7,customplugin:7,cuz:13,dai:16,dampen:11,data:[2,13,16],databas:13,dataset:2,date:[13,15,16],datetim:[13,16],datetime_filt:13,datetime_operation_alia:13,dbg:22,debug:[7,10,11,13,14,16,17,22,23],decemb:16,decid:11,decis:[],decor:22,deep:16,deepli:22,def:[7,11,13],defin:[10,11,13,16,18,23],definit:[13,17,20],deliber:[],demo:[17,23],denot:16,depend:[16,23],depict:11,deploi:13,deprec:6,deriv:[],describ:22,design:[7,10,11,23],desir:23,destin:15,destination_path:2,detail:[0,13,17],develop:13,dialog:10,dict:[10,13,14,16,17,20,22],dict_:16,dict_get:13,dict_travers:22,dictionari:[16,17,20,22],did:[11,16],didn:16,differ:[7,11,13,14,16,17],dim:[3,10,16],dimens:[13,16],dimension_entity_map:[],dir:2,directli:[7,23],directori:2,dissimilar:13,doc:[],document:13,doe:10,doesn:[13,16,22],don:[7,22],done:13,down:13,downstream:13,drop:23,duckl:[13,14,16],duckling_ent:13,duckling_pars:[4,5,13],duckling_plugin:[1,12],duckling_time_ent:16,ducklingpars:6,ducklingplug:6,ducklingplugin:[0,6,7,13,14,23],due:22,durat:[3,13,16],duration_ent:[1,15],durationent:16,dynam:7,each:[10,11,13,14,16],easi:0,either:[2,15,16,22],elect:11,element:[10,13,16,22,23],elimin:[],els:[11,13,16],emit:11,en_gb:13,en_in:13,en_u:13,encourag:7,end:[3,7,10,13,16],enforc:23,english:10,entiti:[0,1,4,5,10,13,14,15,17,20,22,23],entities_json:[],entity_map:[13,14],entity_nam:[],entity_synthesi:16,entity_typ:[10,16],entityclass:14,entitykei:3,environ:[],error:22,especi:13,etc:[13,16,23],evalu:11,even:[7,10],everi:23,everyth:13,evid:11,exampl:[2,7,10,13,15,16],except:22,exclus:22,execut:[22,23],exhibit:[2,23],exist:[2,7,13,22],expect:[7,10,11,13,14,15,16,23],experi:13,explicit:16,explicitli:16,explor:17,expos:[2,7,13],express:13,extend:7,extern:7,extra:13,extract:[10,13,14,20],facebook:[],facilit:13,fact:13,fail:[11,13],fairli:23,fallback:11,fallback_int:11,fals:[7,10,11,13,14,16,17,23],faq:10,featur:7,few:[0,7,10,14,15,23],field:13,file:2,file_path:7,fill:[10,15,17,20,23],fill_multipl:[10,17],fill_slot:17,filler:10,filter:[11,13,16,23],filter_typ:13,find:11,fine:13,first:22,fix:16,flag:14,flatten:13,flavor:16,flexibl:23,flight:16,flush:23,focu:0,follow:23,food:[],foreign:23,forest:11,fork:13,form:13,format:[10,13,16],found:10,framework:0,free:[7,13],frequenc:11,from:[2,3,7,10,11,13,14,16,17,22,23],from_dict:[14,16],futur:13,gap:11,gener:[2,11,15],geographi:13,geopointent:16,get:[0,10,13,16,23],get_date_valu:[],get_ent:14,get_valu:16,getworkflowutterancefn:[13,18],git:2,github:13,gitlab:[],given:[13,16,22],goal:[],goe:11,grain:[3,16],graviti:23,great:13,greater:13,ground:23,group:11,guid:13,hack:14,had:11,hamper:7,handl:[7,10,11,13,16,23],hang:23,has:[7,11,16,17],have:[0,10,11,13,16,17,22,23],head:2,header:[],healthi:11,hello:[2,13],help:[0,2,7,11,13,16,17],here:[2,7,11,13,16,23],heurist:11,high:11,hold:17,hollow:23,hope:[7,13],hour:16,how:11,html:10,http:[10,13],ideal:[7,11,23],ident:13,identifi:[10,16,17],ids:[13,16],impact:[13,14],imper:13,implement:[7,13,16,23],impli:[11,13],improv:[7,11,13],includ:[0,16],inconsequenti:13,index:[0,22],indexerror:[16,22],individu:14,infer:[16,23],info:[13,22],inform:[11,13,16,19],initi:[],inner:23,input:[7,10,11,13,16,22,23],input_:[7,10,11,13,22,23],insert:[7,14,20],instal:2,instanc:[7,11,13,16,17,20,22],instanti:[10,13,16],instead:[6,13,22],intend:16,intent:[0,1,10,11,15,23],intent_detection_slot_fil:10,intent_nam:10,intent_vot:[8,9],interact:[0,7,23],interfac:13,intermedi:[11,14],interv:[3,16],invoc:2,invok:13,involv:14,ipython:22,irrespect:10,is_each_el:13,is_list:13,is_list_of_str:13,is_str:13,is_uniq_date_from_valu:16,is_uniq_day_from_valu:16,is_unsqueezed_utter:13,is_utter:13,isn:[13,23],iso3166:13,iso:[13,16],isol:7,issu:[13,16],item:10,iter:23,its:[7,10,11,13,16,17],join:[7,13],json:[16,17,20,23],judg:23,juli:16,just:[7,13,14],keep:[7,14],kei:[7,13,14,16,20],key_error:22,keyerror:[16,22],know:[13,23],known:16,kolkata:13,kwarg:22,label:14,lambda:[10,11,13,22],lambdax:[],languag:[13,22,23],largest:23,last:[16,22],latent:[3,10,16],latest:2,latitud:16,lead:[11,22],learn:[0,11,23],leav:13,len:11,lesser:13,let:[0,10,11],level:[22,23],lib:13,librari:0,light:23,like:[7,10,11,13,15,16],line:[2,13],link:2,lint:2,list:[10,11,13,14,16,17,20,22,23],list_entity_plugin:[0,12,13],listentityplugin:14,littl:23,load:[7,23],load_corpu:7,load_model:23,local:[2,13],locat:[2,16],location_ent:[1,15],locationent:[10,16],log:[11,22,23],logger:[1,24],logic:22,longitud:16,look:[10,11,13,23],low:[],machin:[0,23],made:[0,7,11],mai:[10,13,23],main:2,make:[0,2,13,16,22,23],makeplugin:[],manag:23,mani:[11,23],manner:16,map:[10,14],mar:22,mark:13,mastercard:13,match:[10,13,14,16,22],matchtyp:14,mayb:17,maybe_utter:13,mean:[11,13,15,17],meant:16,medium:23,mention:16,merg:13,merge_asr_output:[0,1,12],merge_asr_output_plugin:[7,13],met:[7,11],meta:16,method:[7,10,13,14,16,22,23],metric:2,minim:0,minut:16,mismatch:22,miss:[2,13,22],mock:[11,23],model:[2,10,11,13,14,23],modif:[7,16,17],modifi:[11,17,23],modul:[0,24],mondai:16,month:16,more:[10,11,13,16,23],morn:16,most:[13,22],multipl:[11,13,17],must:[2,7,22],mutat:[7,10,11,13,14,16,23],mutate_ent:[],naiv:11,name:[2,3,7,10,11,13,16,17,20,22,23],namespac:2,natur:13,navig:22,nearbi:[],neatli:23,necessari:16,need:[10,11,13,14,16,22,23],neg:[11,16],neither:22,ner:14,ner_search:14,nest:22,new_project:2,night:16,nlp:13,nlpprogress:10,nois:13,non:13,none:[2,7,10,11,13,14,16,17,22,23],nonetyp:2,normal:[10,11,13,16],normalize_utter:[1,12],note:13,noth:[11,16],notic:[10,11,13],notimplementederror:23,now:11,number:[10,11,13,15,16,23],number_ent:10,number_slot:10,numer:[13,16],numerical_ent:[1,15],numericalent:[10,16],obj:[13,22],obj_typ:22,object:[3,7,13,16,17,20,22,23],observ:11,obtain:[11,13,16],occurr:11,oct:16,octob:16,odd:[],offer:[7,23],onc:[7,10,13],one:[10,11,13,15,16],ones:23,onli:[10,11,13,14,16,22],open:[7,16],oper:[13,16],opinion:0,oppos:14,option:[2,7,10,11,13,14,16,17,23],order:[],organ:2,origin:[3,10,15,16],other:[0,10,11,13,14,16,23],out:[10,11,13,16,17,22],output:[7,10,11,13,23],over:[11,14,23],overal:[11,13],overrid:[16,23],overridden:[16,23],owing:13,own:16,packag:[0,24],paint:11,param:22,paramet:[2,10,11,13,14,16,17,22,23],park:16,pars:[13,14,16,22],parser:[0,1,10,13,16,17,24],part:[13,16],parti:7,partial:13,particip:15,pass:[10,11,13,16,22,23],passeng:15,past:13,path:[7,22,23],pattern:[13,14],peopl:[7,10,13,16],people_ent:[1,10,15],people_entity_prop:3,peopleent:[10,16],per:[7,10,13],percentag:11,perform:13,pertain:10,pick:11,pictur:11,pinpoint:16,pip:0,pipe:23,pipelin:[7,23],place:[7,11,13,23],plain:11,planet:22,pleas:6,plugin:[0,1,10,11,13,14,15,16,17,23,24],pluginfn:[7,10,11,14,16,17,18,23],poetri:2,point:[2,7,11],poor:11,popular:0,portabl:[7,23],posit:[13,16],possibl:[16,17,22],post:[7,23],post_init:16,postprocess:[0,1,16,17,23,24],postprocessor:[0,3,10,11,16,17,23],pprint:10,practic:10,pre:[7,10,18,23],preceed:[],precis:13,predict:[11,23],prefer:[17,22],preprocess:[0,1,23,24],preprocessor:[0,3,10,11,13,23],present:10,preset:10,prevent:[13,14,16],previou:16,priorit:[],pristin:14,privat:13,problem:[0,13],procedur:23,process:[7,13,23],processor:23,processor_typ:23,produc:[11,13],product:[11,16,17],progress:[0,15,16,17],project:[1,3,15,22,23,24],prop:13,properti:[13,16,22],property_:16,proport:11,provid:[3,7,10,11,13,16,18,19,21,22],proxi:23,purpos:16,put:23,python:[],pythoncod:22,pytz:13,quarter:16,queri:[],rais:[11,13,16,22,23],rang:[3,10,16,22],rank:11,rather:[],reach:13,read:[7,13],readi:[0,11],readthedoc:[],recal:13,receiv:[11,23],recent:22,recurs:22,reduc:[11,22],refactor:14,refer:[2,13,16],reference_tim:[],reftim:13,regex:14,regex_search:14,rel:[],relai:23,relat:[10,13],relationship:[10,15],releas:2,remain:11,remov:[17,20],replac:16,report:10,repres:[10,13],represent:[3,11,16],request:[],requir:[7,13,14,15,23],reserv:15,reset:23,reshap:16,resid:13,resort:11,respect:[13,15,16],respons:13,restaur:[],restrict:[7,22,23],result:23,retriev:[],review:0,root:2,round:15,rtype:[16,22],rule:[10,17],rule_slot_fil:[8,9],rule_str:10,rulebasedslotfillerplugin:[0,7,10,17,23],ruleslotfil:[],ruleslotfilerplugin:7,run:[7,10,11,13,22,23],runtim:7,safe:[7,11,16],safe_load:10,safeguard:23,safest:11,sai:[11,16,23],said:16,same:[7,14,17],saturdai:16,sauci:23,scaffold:[0,2],schema:10,score:[10,11,16,17],screen:2,search:[13,14],searchstrategyclass:14,second:[13,16],section:[13,15,16],see:23,select:13,select_datetim:13,self:[7,16],semant:13,sentenc:[13,15,16],sentence2vecplugin:7,separ:[7,13],server:13,servic:[13,14],session:0,set:[7,10,11,13,14,15,16,17,22],set_entity_typ:16,set_valu:16,shall:10,shape:14,share:17,shift:23,ship:[7,13,14],should:[11,13,16,17,23],show:[2,14],sic:23,signal:[0,1,3,11,15],signatur:[10,23],signific:[10,13,15],similar:[11,13,23],simpl:[0,2,7,13,23],simpli:13,simplifi:[],simul:11,sinc:[6,7,11,13,16],singl:[10,11,13,17],situat:11,size:11,skip:16,skip_entity_attr:16,slot:[0,1,10,11,15,17,23],slot_fil:[0,8,9],slot_nam:[3,10,16],slot_rul:10,slot_typ:17,slotfil:[],slow:13,slu:[0,11,15,23],smallest:16,solut:[0,7],some:[7,11,13,16,23],somewher:13,sort:[13,23],sourc:[2,3,7,10,11,13,14,16,17,20,22,23],spaci:14,spacy_nlp:14,sparingli:22,speaker:22,special:17,specif:[13,16,22],specifi:[2,7,13],speech:0,splitlin:7,stabl:[],stack:0,stage:7,stall:13,standard:13,start:[2,3,10,13,16],state:[11,13],statist:23,statu:[],store:16,str:[2,7,10,11,13,14,16,17,20,22,23],strategi:[13,14],strength:[3,11],string:[11,13,14,16],strong:11,stronger:23,structur:[1,7,13,14,16],style:14,sub:[0,23],subclass:[13,16,23],submodul:[1,4,5,8,9,12,15,24],subpackag:24,sugar:[16,22],summar:7,summari:[],sundai:16,supplier:23,support:[2,13,16,17,23],suppos:[16,23],sure:13,syntat:22,synthet:10,system:[10,13],tag:2,tailor:7,take:[2,11,23],target:[],task:[13,23],tell:[10,11,15,16],templat:[0,2],tend:13,termin:13,test:[],test_duckling_pars:[],test_ent:[],test_merge_asr_output:[],test_plugin:[],test_rule_slot_fil:[],test_workflow:[],text:[0,1,4,8,12,17],than:[10,11,13],thei:[13,16,23],them:[7,10,13,22],therefor:[7,16],thi:[2,7,10,11,13,14,15,16,17,19,20,22,23],think:23,third:[7,10],those:[13,16,22,23],though:13,threshold:11,through:[10,13,16,23],throughout:[7,22],throughtout:3,thu:[],thud:23,ticket:15,till:16,time:[10,13,14,15,16,22],time_ent:[1,15],time_entity_prop:3,time_interval_ent:[1,15],time_slot:10,timeent:[10,16],timeinterv:13,timeintervalent:16,timeout:13,timestamp:16,timezon:13,todai:16,togeth:16,token:[10,11,15,16],tomorrow:16,tonight:16,tool:14,top:11,total:11,traceback:22,track:13,train:[],transcript:[11,13,14],transform:[0,2,13],travel:15,travers:22,traverse_dict:22,tree:11,trial:11,trip:15,triplet:16,tupl:[2,10,11,13,14,22],tutori:[],two:[10,11,16,22,23],type:[0,1,2,3,10,11,13,14,22,23,24],type_:13,typeerror:[11,13,22,23],umm:13,unawar:7,under:[11,13],undergo:22,understand:17,union:[13,22],uniqu:[11,13,16],unit:[3,10,16],unk:11,unless:10,unsaf:[11,16],unset:13,updat:[7,16,17,22,23],update_int:11,update_workflow:13,updateworkflowstringfn:[13,18],upon:15,upto:[],url:13,urlencod:[],usabl:[],usag:[2,7],use:[0,2,6,7,10,13,15,23],used:[3,13,16,22,23],useful:[7,22],user:[2,16],usernam:[],uses:2,using:[0,2,11,13,14,16,17,22,23],usual:7,utf:[],util:[0,1,2,7,10,11,13,14,16,17,24],utter:[0,1,13,15,16],valid:[13,16],validate_typ:22,valu:[3,7,10,11,13,14,16,17,20,22,23],valueerror:[],variant:16,variou:[7,13],vcs:2,vcs_ref:2,vector:13,veri:[11,13,23],verifi:16,vernacular:[2,13],version:[2,6,23],vertic:23,via:[7,14,22],vote:[0,8,9],vote_plugin:11,vote_sign:11,voteintentplugin:11,voteplugin:[0,7,11,13,23],wai:[7,11,13,15,22],want:[13,16,17,23],warn:22,weak:11,week:16,weekdai:16,weight:11,well:[13,16,23],went:16,were:[13,16,17,23],when:13,where:[2,11,13,16,17,23],which:[11,13,14,16,17,23],whole:16,why:23,win:11,wish:16,within:[13,14,15,16,17,20,22,23],without:[22,23],won:[7,23],words2num_plugin:7,work:[13,15,23],workflow:[0,1,7,10,11,13,14,24],workflow_public_properti:3,world:[2,13],worri:23,worst:11,would:[13,15,23],wrap:22,wrapper:14,write:[0,7],written:7,www:[],yaml:10,year:16,yep:11,yes:[11,23],yesterdai:16,yet:11,yield:11,you:[0,10,13,15,23],your:[0,23],your_project_nam:0},titles:["Dialogy","dialogy package","dialogy.cli package","dialogy.constants package","dialogy.parser package","dialogy.parser.text package","dialogy.parser.text.entity package","dialogy.plugin package","dialogy.postprocess package","dialogy.postprocess.text package","dialogy.postprocess.text.slot_filler package","dialogy.postprocess.text.voting package","dialogy.preprocess package","dialogy.preprocess.text package","dialogy.preprocess.text.list_entity_plugin package","dialogy.types package","dialogy.types.entity package","dialogy.types.intent package","dialogy.types.plugin package","dialogy.types.signal package","dialogy.types.slots package","dialogy.types.utterances package","dialogy.utils package","dialogy.workflow package","dialogy"],titleterms:{advantag:23,base_ent:16,cli:2,constant:3,content:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],dialogi:[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24],duckling_pars:6,duckling_plugin:13,duration_ent:16,entiti:[6,16],faq:0,instal:0,intent:17,intent_vot:11,list_entity_plugin:14,location_ent:16,logger:22,merge_asr_output:13,modul:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],normalize_utter:13,numerical_ent:16,packag:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],parser:[4,5,6],people_ent:16,plugin:[7,18],postprocess:[8,9,10,11],preprocess:[12,13,14],project:[0,2],rule_slot_fil:10,section:0,signal:19,slot:20,slot_fil:10,start:0,structur:23,submodul:[2,6,7,10,11,13,16,19,22,23],subpackag:[1,4,5,8,9,12,13,15],test:0,text:[5,6,9,10,11,13,14],time_ent:16,time_interval_ent:16,type:[15,16,17,18,19,20,21],util:22,utter:21,vote:11,workflow:23}})
\ No newline at end of file
diff --git a/docs/source/dialogy.preprocess.text.html b/docs/source/dialogy.preprocess.text.html
index 8dbc2a2e..d9e7712f 100644
--- a/docs/source/dialogy.preprocess.text.html
+++ b/docs/source/dialogy.preprocess.text.html
@@ -273,7 +273,7 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 </td></tr></table></div></div>
 <dl class="py class">
 <dt id="dialogy.preprocess.text.duckling_plugin.DucklingPlugin">
-<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">dialogy.preprocess.text.duckling_plugin.</span></code><code class="sig-name descname"><span class="pre">DucklingPlugin</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dimensions</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">List</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></span></em>, <em class="sig-param"><span class="n"><span class="pre">timezone</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">timeout</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">float</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">0.5</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">url</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">str</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">'http://0.0.0.0:8000/parse'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">locale</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">str</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">'en_IN'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">access</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Callable</span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">…</span></span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">mutate</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Callable</span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">…</span></span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">entity_map</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">debug</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">bool</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="../_modules/dialogy/preprocess/text/duckling_plugin.html#DucklingPlugin"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin" title="Permalink to this definition">¶</a></dt>
+<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">dialogy.preprocess.text.duckling_plugin.</span></code><code class="sig-name descname"><span class="pre">DucklingPlugin</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dimensions</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">List</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></span></em>, <em class="sig-param"><span class="n"><span class="pre">timezone</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">timeout</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">float</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">0.5</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">url</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">str</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">'http://0.0.0.0:8000/parse'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">locale</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">str</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">'en_IN'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">datetime_filters</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">access</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Callable</span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">…</span></span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">mutate</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Callable</span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">[</span></span><span class="p"><span class="pre">…</span></span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">entity_map</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">debug</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">bool</span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="../_modules/dialogy/preprocess/text/duckling_plugin.html#DucklingPlugin"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin" title="Permalink to this definition">¶</a></dt>
 <dd><p>Bases: <a class="reference internal" href="dialogy.plugin.html#dialogy.plugin.plugin.Plugin" title="dialogy.plugin.plugin.Plugin"><code class="xref py py-class docutils literal notranslate"><span class="pre">dialogy.plugin.plugin.Plugin</span></code></a></p>
 <p>A <a class="reference internal" href="dialogy.plugin.html#plugin"><span class="std std-ref">Plugin</span></a> for extracting entities using <a class="reference external" href="https://github.com/facebook/duckling">Duckling</a>. Once
 instantiated, a <code class="code docutils literal notranslate"><span class="pre">duckling_parser</span></code> object will interface to an http server, running <a class="reference external" href="https://github.com/facebook/duckling">Duckling</a>.</p>
@@ -324,10 +324,74 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 <dd class="field-odd"><p><strong>url</strong> (<em>Optional</em><em>[</em><em>str</em><em>]</em>) – The address where Duckling’s entity parser can be reached, defaults to “<a class="reference external" href="http://0.0.0.0:8000/parse">http://0.0.0.0:8000/parse</a>”.</p>
 </dd>
 </dl>
+<dl class="py attribute">
+<dt id="dialogy.preprocess.text.duckling_plugin.DucklingPlugin.DATETIME_OPERATION_ALIAS">
+<code class="sig-name descname"><span class="pre">DATETIME_OPERATION_ALIAS</span></code><em class="property"> <span class="pre">=</span> <span class="pre">{'future':</span> <span class="pre">&lt;built-in</span> <span class="pre">function</span> <span class="pre">ge&gt;,</span> <span class="pre">'past':</span> <span class="pre">&lt;built-in</span> <span class="pre">function</span> <span class="pre">le&gt;}</span></em><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.DATETIME_OPERATION_ALIAS" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+<dl class="py attribute">
+<dt id="dialogy.preprocess.text.duckling_plugin.DucklingPlugin.FUTURE">
+<code class="sig-name descname"><span class="pre">FUTURE</span></code><em class="property"> <span class="pre">=</span> <span class="pre">'future'</span></em><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.FUTURE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+<dl class="py attribute">
+<dt id="dialogy.preprocess.text.duckling_plugin.DucklingPlugin.PAST">
+<code class="sig-name descname"><span class="pre">PAST</span></code><em class="property"> <span class="pre">=</span> <span class="pre">'past'</span></em><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.PAST" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+<dl class="py method">
+<dt id="dialogy.preprocess.text.duckling_plugin.DucklingPlugin.apply_filters">
+<code class="sig-name descname"><span class="pre">apply_filters</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">entities</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">List</span><span class="p"><span class="pre">[</span></span><a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity"><span class="pre">dialogy.types.entity.base_entity.BaseEntity</span></a><span class="p"><span class="pre">]</span></span></span></em><span class="sig-paren">)</span> → <span class="pre">List</span><span class="p"><span class="pre">[</span></span><a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity"><span class="pre">dialogy.types.entity.base_entity.BaseEntity</span></a><span class="p"><span class="pre">]</span></span><a class="reference internal" href="../_modules/dialogy/preprocess/text/duckling_plugin.html#DucklingPlugin.apply_filters"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.apply_filters" title="Permalink to this definition">¶</a></dt>
+<dd><p>Filter entities by configurable criteria.</p>
+<p>The utility of this method is tracked here:
+<a class="reference external" href="https://github.com/Vernacular-ai/dialogy/issues/42">https://github.com/Vernacular-ai/dialogy/issues/42</a></p>
+<p>We needed a way to express, not all datetime entities are needed. There are needs which can be
+expressed as filters: want greater or lesser than the reference time, etc. There are more applications
+where we expect sorting, filtering by other attributes as well. This method is an advent of such expressions.</p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters</dt>
+<dd class="field-odd"><p><strong>entities</strong> (<em>List</em><em>[</em><a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity"><em>BaseEntity</em></a><em>]</em>) – A list of entities.</p>
+</dd>
+<dt class="field-even">Returns</dt>
+<dd class="field-even"><p>A list of entities obtained after applying filters.</p>
+</dd>
+<dt class="field-odd">Return type</dt>
+<dd class="field-odd"><p>List[<a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity">BaseEntity</a>]</p>
+</dd>
+</dl>
+</dd></dl>
+<dl class="py method">
+<dt id="dialogy.preprocess.text.duckling_plugin.DucklingPlugin.select_datetime">
+<code class="sig-name descname"><span class="pre">select_datetime</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">entities</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">List</span><span class="p"><span class="pre">[</span></span><a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity"><span class="pre">dialogy.types.entity.base_entity.BaseEntity</span></a><span class="p"><span class="pre">]</span></span></span></em>, <em class="sig-param"><span class="n"><span class="pre">filter_type</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Any</span></span></em><span class="sig-paren">)</span> → <span class="pre">List</span><span class="p"><span class="pre">[</span></span><a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity"><span class="pre">dialogy.types.entity.base_entity.BaseEntity</span></a><span class="p"><span class="pre">]</span></span><a class="reference internal" href="../_modules/dialogy/preprocess/text/duckling_plugin.html#DucklingPlugin.select_datetime"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.select_datetime" title="Permalink to this definition">¶</a></dt>
+<dd><p>Select datetime entities as per the filters provided in the configuration.</p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters</dt>
+<dd class="field-odd"><ul class="simple">
+<li><p><strong>entities</strong> (<em>List</em><em>[</em><a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity"><em>BaseEntity</em></a><em>]</em>) – A list of entities.</p></li>
+<li><p><strong>filter_type</strong> (<em>str</em>) – </p></li>
+</ul>
+</dd>
+<dt class="field-even">Returns</dt>
+<dd class="field-even"><p>List of entities obtained after applying comparator functions.</p>
+</dd>
+<dt class="field-odd">Return type</dt>
+<dd class="field-odd"><p>List[<a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity">BaseEntity</a>]</p>
+</dd>
+</dl>
+</dd></dl>
 <dl class="py method">
 <dt id="dialogy.preprocess.text.duckling_plugin.DucklingPlugin.utility">
 <code class="sig-name descname"><span class="pre">utility</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Any</span></span></em><span class="sig-paren">)</span> → <span class="pre">List</span><span class="p"><span class="pre">[</span></span><a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity"><span class="pre">dialogy.types.entity.base_entity.BaseEntity</span></a><span class="p"><span class="pre">]</span></span><a class="reference internal" href="../_modules/dialogy/preprocess/text/duckling_plugin.html#DucklingPlugin.utility"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.preprocess.text.duckling_plugin.DucklingPlugin.utility" title="Permalink to this definition">¶</a></dt>
-<dd></dd></dl>
+<dd><p>Produces Duckling entities, runs with a <a class="reference internal" href="dialogy.workflow.html#workflow-run"><span class="std std-ref">Workflow’s run</span></a> method.</p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters</dt>
+<dd class="field-odd"><p><strong>args</strong> (<em>Tuple</em><em>(</em><em>str</em><em>, </em><em>int</em><em>, </em><em>str</em><em>)</em>) – Expects a tuple of <code class="code docutils literal notranslate"><span class="pre">Tuple[natural</span> <span class="pre">language</span> <span class="pre">for</span> <span class="pre">parsing</span> <span class="pre">entities,</span> <span class="pre">reference</span> <span class="pre">time</span> <span class="pre">in</span> <span class="pre">seconds,</span> <span class="pre">locale]</span></code></p>
+</dd>
+<dt class="field-even">Returns</dt>
+<dd class="field-even"><p>A list of duckling entities.</p>
+</dd>
+<dt class="field-odd">Return type</dt>
+<dd class="field-odd"><p>List[<a class="reference internal" href="dialogy.types.entity.html#dialogy.types.entity.base_entity.BaseEntity" title="dialogy.types.entity.base_entity.BaseEntity">BaseEntity</a>]</p>
+</dd>
+</dl>
+</dd></dl>
 </dd></dl>
 </div>
 <div class="section" id="module-dialogy.preprocess.text.merge_asr_output">
diff --git a/docs/source/dialogy.types.entity.html b/docs/source/dialogy.types.entity.html
index d59dd25e..f693ddf3 100644
--- a/docs/source/dialogy.types.entity.html
+++ b/docs/source/dialogy.types.entity.html
@@ -255,7 +255,7 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 </dd></dl>
 <dl class="py method">
 <dt id="dialogy.types.entity.base_entity.BaseEntity.get_value">
-<code class="sig-name descname"><span class="pre">get_value</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span> → <span class="pre">Any</span><a class="reference internal" href="../_modules/dialogy/types/entity/base_entity.html#BaseEntity.get_value"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.types.entity.base_entity.BaseEntity.get_value" title="Permalink to this definition">¶</a></dt>
+<code class="sig-name descname"><span class="pre">get_value</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Any</span></span></em><span class="sig-paren">)</span> → <span class="pre">Any</span><a class="reference internal" href="../_modules/dialogy/types/entity/base_entity.html#BaseEntity.get_value"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.types.entity.base_entity.BaseEntity.get_value" title="Permalink to this definition">¶</a></dt>
 <dd><p>Get value of an entity.</p>
 <p>The structure of an entity conceals the value in different data structures.
 This is sugar for access.</p>
@@ -511,8 +511,8 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 <code class="sig-name descname"><span class="pre">entity_type</span></code><em class="property"><span class="pre">:</span> <span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></em><a class="headerlink" href="#dialogy.types.entity.time_entity.TimeEntity.entity_type" title="Permalink to this definition">¶</a></dt>
 <dd></dd></dl>
 <dl class="py method">
-<dt id="dialogy.types.entity.time_entity.TimeEntity.get_date_value">
-<code class="sig-name descname"><span class="pre">get_date_value</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">date</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span> </span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></span></em><span class="sig-paren">)</span> → <span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span><a class="reference internal" href="../_modules/dialogy/types/entity/time_entity.html#TimeEntity.get_date_value"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.types.entity.time_entity.TimeEntity.get_date_value" title="Permalink to this definition">¶</a></dt>
+<dt id="dialogy.types.entity.time_entity.TimeEntity.get_value">
+<code class="sig-name descname"><span class="pre">get_value</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">date</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span> </span><span class="pre">str</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span> → <span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">datetime.datetime</span><span class="p"><span class="pre">]</span></span><a class="reference internal" href="../_modules/dialogy/types/entity/time_entity.html#TimeEntity.get_value"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.types.entity.time_entity.TimeEntity.get_value" title="Permalink to this definition">¶</a></dt>
 <dd><p>Return the date string in ISO format from the dictionary passed</p>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">date</span> <span class="o">=</span> <span class="p">{</span>
     <span class="s2">"value"</span><span class="p">:</span> <span class="s2">"2021-04-17T16:00:00.000+05:30"</span><span class="p">,</span>
@@ -529,7 +529,7 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 <dd class="field-even"><p><code class="code docutils literal notranslate"><span class="pre">date["value"]</span></code></p>
 </dd>
 <dt class="field-odd">Return type</dt>
-<dd class="field-odd"><p>Optional[str]</p>
+<dd class="field-odd"><p>Optional[datetime]</p>
 </dd>
 </dl>
 </dd></dl>
@@ -696,8 +696,8 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 <code class="sig-name descname"><span class="pre">entity_type</span></code><em class="property"><span class="pre">:</span> <span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></em><a class="headerlink" href="#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.entity_type" title="Permalink to this definition">¶</a></dt>
 <dd></dd></dl>
 <dl class="py method">
-<dt id="dialogy.types.entity.time_interval_entity.TimeIntervalEntity.get_date_value">
-<code class="sig-name descname"><span class="pre">get_date_value</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">date</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span></span></em><span class="sig-paren">)</span> → <span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span><a class="reference internal" href="../_modules/dialogy/types/entity/time_interval_entity.html#TimeIntervalEntity.get_date_value"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.get_date_value" title="Permalink to this definition">¶</a></dt>
+<dt id="dialogy.types.entity.time_interval_entity.TimeIntervalEntity.get_value">
+<code class="sig-name descname"><span class="pre">get_value</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">date</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span> </span><span class="pre">Any</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></span> <span class="o"><span class="pre">=</span></span> <span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span> → <span class="pre">Optional</span><span class="p"><span class="pre">[</span></span><span class="pre">datetime.datetime</span><span class="p"><span class="pre">]</span></span><a class="reference internal" href="../_modules/dialogy/types/entity/time_interval_entity.html#TimeIntervalEntity.get_value"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.types.entity.time_interval_entity.TimeIntervalEntity.get_value" title="Permalink to this definition">¶</a></dt>
 <dd><p>Return the date string in ISO format from the dictionary passed</p>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">date</span> <span class="o">=</span> <span class="p">{</span>
     <span class="s2">"from"</span><span class="p">:</span> <span class="p">{</span>
@@ -716,7 +716,7 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 <dd class="field-even"><p><code class="code docutils literal notranslate"><span class="pre">date["value"]</span></code></p>
 </dd>
 <dt class="field-odd">Return type</dt>
-<dd class="field-odd"><p>Optional[str]</p>
+<dd class="field-odd"><p>Optional[datetime]</p>
 </dd>
 </dl>
 </dd></dl>
diff --git a/docs/source/dialogy.utils.html b/docs/source/dialogy.utils.html
index 05dbf2de..38f03c29 100644
--- a/docs/source/dialogy.utils.html
+++ b/docs/source/dialogy.utils.html
@@ -293,14 +293,14 @@ <h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this
 <span class="o">&lt;</span><span class="n">ipython</span><span class="o">-</span><span class="nb">input</span><span class="o">-</span><span class="mi">4</span><span class="o">-</span><span class="mi">556</span><span class="n">a11057179</span><span class="o">&gt;</span> <span class="ow">in</span> <span class="o">&lt;</span><span class="n">module</span><span class="o">&gt;</span>
 <span class="ne">----&gt; </span><span class="mi">1</span> <span class="n">traverse_dict</span><span class="p">(</span><span class="n">input_</span><span class="p">,</span> <span class="p">[</span><span class="s2">"planets"</span><span class="p">,</span> <span class="s2">"mars"</span><span class="p">,</span> <span class="mi">0</span> <span class="p">,</span> <span class="s2">"languages"</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="s2">"bop"</span><span class="p">])</span>
 
-<span class="nn">~/python/dialogy/dialogy/utils/__init__.py</span> in <span class="ni">traverse_dict</span><span class="nt">(obj, properties)</span>
+<span class="nn">~/pythoncode/dialogy/dialogy/utils/__init__.py</span> in <span class="ni">traverse_dict</span><span class="nt">(obj, properties)</span>
 <span class="g g-Whitespace">     </span><span class="mi">50</span>     <span class="sd">"""</span>
 <span class="g g-Whitespace">     </span><span class="mi">51</span><span class="sd">     try:</span>
 <span class="ne">---&gt; </span><span class="mi">52</span><span class="sd">         return reduce(lambda o, k: o[k], properties, obj)</span>
 <span class="g g-Whitespace">     </span><span class="mi">53</span><span class="sd">     except KeyError as key_error:</span>
 <span class="g g-Whitespace">     </span><span class="mi">54</span><span class="sd">         raise KeyError(</span>
 
-<span class="nn">~/python/dialogy/dialogy/utils/__init__.py</span> in <span class="ni">&lt;lambda&gt;</span><span class="nt">(o, k)</span>
+<span class="nn">~/pythoncode/dialogy/dialogy/utils/__init__.py</span> in <span class="ni">&lt;lambda&gt;</span><span class="nt">(o, k)</span>
 <span class="g g-Whitespace">     </span><span class="mi">50</span><span class="sd">     """</span>
 <span class="g g-Whitespace">     </span><span class="mi">51</span>     <span class="k">try</span><span class="p">:</span>
 <span class="ne">---&gt; </span><span class="mi">52</span>         <span class="k">return</span> <span class="n">reduce</span><span class="p">(</span><span class="k">lambda</span> <span class="n">o</span><span class="p">,</span> <span class="n">k</span><span class="p">:</span> <span class="n">o</span><span class="p">[</span><span class="n">k</span><span class="p">],</span> <span class="n">properties</span><span class="p">,</span> <span class="n">obj</span><span class="p">)</span>
diff --git a/docs/source/dialogy.workflow.html b/docs/source/dialogy.workflow.html
index 0b7ddc3f..62b27445 100644
--- a/docs/source/dialogy.workflow.html
+++ b/docs/source/dialogy.workflow.html
@@ -290,7 +290,7 @@ <h3>Advantages<a class="headerlink" href="#advantages" title="Permalink to this
 <dl class="py method">
 <dt id="dialogy.workflow.workflow.Workflow.run">
 <code class="sig-name descname"><span class="pre">run</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">input_</span></span><span class="p"><span class="pre">:</span></span> <span class="n"><span class="pre">Any</span></span></em><span class="sig-paren">)</span> → <span class="pre">Any</span><a class="reference internal" href="../_modules/dialogy/workflow/workflow.html#Workflow.run"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#dialogy.workflow.workflow.Workflow.run" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get final results from the workflow.</p>
+<dd><p id="workflow-run">Get final results from the workflow.</p>
 <p>The current workflow exhibits the following simple procedure:
 pre-processing -&gt; inference -&gt; post-processing.</p>
 <dl class="simple">


Test patch:
diff --git a/tests/preprocess/text/test_cases.yaml b/tests/preprocess/text/test_cases.yaml
index 4e61fb7c..3ef64fba 100644
--- a/tests/preprocess/text/test_cases.yaml
+++ b/tests/preprocess/text/test_cases.yaml
@@ -333,3 +333,135 @@
   'dim': 'time',
   'latent': False}]
   expected: [{"entity": "TimeEntity"}]
+
+- description: "Filter out future dates only."
+  input: ""
+  duckling:
+    locale: "hi_IN"
+    dimensions: ["time", "date"]
+    timezone: "Asia/Kolkata"
+    datetime_filters: "future"
+    debug: True
+  mock_entity_json: [{
+    'body': 'परसो शाम 5 बजे',
+    'dim': 'time',
+    'latent': False,
+    'end': 23,
+    'start': 9,
+    'value': {
+      'values': [{
+        'grain': 'hour',
+        'type': 'value',
+        'value': '2021-05-31T17:00:00.000+05:30'
+      }],
+      'grain': 'hour',
+      'type': 'value',
+      'value': '2021-05-31T17:00:00.000+05:30'
+    }
+  },{
+    'body': 'परसो शाम 5 बजे',
+    'dim': 'time',
+    'latent': False,
+    'end': 23,
+    'start': 9,
+    'value': {
+      'values': [{
+        'grain': 'hour',
+        'type': 'value',
+        'value': '2021-06-04T17:00:00.000+05:30'}
+      ],
+      'grain': 'hour',
+      'type': 'value',
+      'value': '2021-06-04T17:00:00.000+05:30'
+    }
+  }]
+  reference_time: '2021-06-02T18:51:11.000+05:30'
+  expected: [{"entity": "TimeEntity"}]
+
+- description: "Exceptions due to incorrect date filter name."
+  input: ""
+  duckling:
+    locale: "hi_IN"
+    dimensions: ["time", "date"]
+    timezone: "Asia/Kolkata"
+    datetime_filters: "latest"
+    debug: True
+  mock_entity_json: [{
+    'body': 'परसो शाम 5 बजे',
+    'dim': 'time',
+    'latent': False,
+    'end': 23,
+    'start': 9,
+    'value': {
+      'values': [{
+        'grain': 'hour',
+        'type': 'value',
+        'value': '2021-05-31T17:00:00.000+05:30'
+      }],
+      'grain': 'hour',
+      'type': 'value',
+      'value': '2021-05-31T17:00:00.000+05:30'
+    }
+  },{
+    'body': 'परसो शाम 5 बजे',
+    'dim': 'time',
+    'latent': False,
+    'end': 23,
+    'start': 9,
+    'value': {
+      'values': [{
+        'grain': 'hour',
+        'type': 'value',
+        'value': '2021-06-04T17:00:00.000+05:30'}
+      ],
+      'grain': 'hour',
+      'type': 'value',
+      'value': '2021-06-04T17:00:00.000+05:30'
+    }
+  }]
+  reference_time: '2021-06-02T18:51:11.000+05:30'
+  exception: "ValueError"
+
+- description: "Exceptions due to incorrect date filter type."
+  input: ""
+  duckling:
+    locale: "hi_IN"
+    dimensions: ["time", "date"]
+    timezone: "Asia/Kolkata"
+    datetime_filters: 12
+    debug: True
+  mock_entity_json: [{
+    'body': 'परसो शाम 5 बजे',
+    'dim': 'time',
+    'latent': False,
+    'end': 23,
+    'start': 9,
+    'value': {
+      'values': [{
+        'grain': 'hour',
+        'type': 'value',
+        'value': '2021-05-31T17:00:00.000+05:30'
+      }],
+      'grain': 'hour',
+      'type': 'value',
+      'value': '2021-05-31T17:00:00.000+05:30'
+    }
+  },{
+    'body': 'परसो शाम 5 बजे',
+    'dim': 'time',
+    'latent': False,
+    'end': 23,
+    'start': 9,
+    'value': {
+      'values': [{
+        'grain': 'hour',
+        'type': 'value',
+        'value': '2021-06-04T17:00:00.000+05:30'}
+      ],
+      'grain': 'hour',
+      'type': 'value',
+      'value': '2021-06-04T17:00:00.000+05:30'
+    }
+  }]
+  reference_time: '2021-06-02T18:51:11.000+05:30'
+  exception: "TypeError"
diff --git a/tests/preprocess/text/test_duckling_plugin.py b/tests/preprocess/text/test_duckling_plugin.py
index a3bf31d9..1202f811 100644
--- a/tests/preprocess/text/test_duckling_plugin.py
+++ b/tests/preprocess/text/test_duckling_plugin.py
@@ -1,3 +1,4 @@
+import datetime
 import importlib
 
 import httpretty
@@ -82,9 +83,12 @@ def test_plugin_working_cases(payload) -> None:
     duckling_args = payload.get("duckling")
     response_code = payload.get("response_code", 200)
     locale = payload.get("locale")
+    reference_time = payload.get("reference_time")
+    if reference_time is not None:
+        reference_time = datetime.datetime.fromisoformat(reference_time)
 
     def access(workflow):
-        return workflow.input, None, locale
+        return workflow.input, reference_time, locale
 
     def mutate(workflow, entities):
         workflow.output = {"entities": entities}
diff --git a/tests/types/entity/test_entities.py b/tests/types/entity/test_entities.py
index 487b2860..013716ae 100644
--- a/tests/types/entity/test_entities.py
+++ b/tests/types/entity/test_entities.py
@@ -2,6 +2,7 @@
 Tests for entities
 """
 import importlib
+from datetime import datetime
 
 import httpretty
 import pytest
@@ -317,7 +318,7 @@ def test_bad_interval_entity_neither_from_nor_to() -> None:
         values=[value],
     )
     with pytest.raises(KeyError):
-        entity.get_date_value(value)
+        entity.get_value(value)
 
 
 def test_bad_time_entity_invalid_value() -> None:
@@ -331,7 +332,7 @@ def test_bad_time_entity_invalid_value() -> None:
         values=[value],
     )
     with pytest.raises(KeyError):
-        entity.get_date_value(value)
+        entity.get_value(value)
 
 
 def test_bad_time_entity_no_value() -> None:
@@ -365,6 +366,25 @@ def test_time_interval_entity_value_neither_from_nor_to() -> None:
         entity.set_value(value)
 
 
+def test_time_interval_entity_get_value() -> None:
+    body = "to 4 am"
+    value = {
+        "to": {"value": "2021-06-03T17:00:00.000+05:30", "grain": "hour"},
+        "from": {"value": "2021-06-03T15:00:00.000+05:30", "grain": "hour"},
+        "type": "interval",
+    }
+    entity = TimeIntervalEntity(
+        range={"from": 0, "to": len(body)},
+        body=body,
+        type="time",
+        grain="hour",
+        values=[value],
+        value=value,
+    )
+    value = "2021-06-03T15:00:00+05:30"
+    assert entity.get_value() == datetime.fromisoformat(value)
+
+
 def test_time_interval_entity_no_value() -> None:
     body = "to 4 am"
     value = {