Merge pull request #35 from transhapHigsn/feat/choice_flow_2

Feat/choice flow 2

Author: transhapHigsn

README.md

@@ -1,4 +1,4 @@
-# freak
+# Freak
 
 <div align="center">
 
@@ -33,10 +33,17 @@ Since, we have a basic understanding of what exactly a flow in freak is, let's m
 
 - **Butler** is responsible for reading python modules, locating steps and organizing them using locator specified by flow.
 
-- **Executor** is core component of the engine. It is responsible for executing steps. Currently, it only supports linear flows.
+- **Executor** is core component of the engine. It is responsible for executing steps. Currently, it only supports linear and choice-based flows.
 
 - **Inspector** is used to return input schema for every step defined by the flow. This is intended to be part of view logic of the engine.
 
+## Supported flows
+
+- Linear Flows
+- Choice Flows
+
+## Sample Code
+
 **Freak** is currently under active development. Following code should give you an idea how it implements data flows.
 
 This is how you define a flow using base flow.
@@ -117,10 +124,11 @@ def func_four(ctx: RequestContext) -> Response:
 Following test case will use above defintion to execute the flow.
 
 ```python
-from freak.engine import Engine
+from freak.provider import EngineProvider
 
 def test_base_flow_prosecutioner():
-    executioner = Engine(module_name=__name__, decorator_name="base_flow")
+    engine = EngineProvider(flow_name="base_flow").engine
+    executioner = engine(module_name=__name__, decorator_name="base_flow")
 
     response = executioner.execute(data={"a": 4, "b": 7}, from_step="func_one")
 
@@ -183,10 +191,11 @@ def test_base_flow_prosecutioner():
 Using above code, it is also possible to generate input schema for every step. Following test case will demonstrate this behaviour.
 
 ```python
-from freak.engine import Engine
+from freak.provider import EngineProvider
 
 def test_base_flow_fetch_schema():
-    executioner = Engine(module_name=__name__, decorator_name="base_flow")
+    engine = EngineProvider(flow_name="base_flow").engine
+    executioner = engine(module_name=__name__, decorator_name="base_flow")
     responses = executioner.inspect()
 
     input_model_b_schema = {
@@ -214,10 +223,14 @@ def test_base_flow_fetch_schema():
     assert input_model_schema == InputModel.schema()
     assert input_model_b_schema == InputModelB.schema()
 
-    assert responses[0]["schema"] == input_model_schema
-    assert responses[1]["schema"] == input_model_schema
-    assert responses[2]["schema"] == input_model_schema
-    assert responses[3]["schema"] == input_model_b_schema
+    assert executioner.flow.predecessor == responses["graph"]
+
+    schema_info = responses["schema"]
+
+    assert schema_info["func_one"]["schema"] == input_model_schema
+    assert schema_info["func_two"]["schema"] == input_model_schema
+    assert schema_info["func_three"]["schema"] == input_model_schema
+    assert schema_info["func_four"]["schema"] == input_model_b_schema
 ```
 
 <!-- ## Very first steps

freak/engine.py

@@ -5,7 +5,7 @@
 from inspect import getabsfile
 
 from freak.models.request import FetchSchemaRequestContext, RequestContext
-from freak.models.response import EngineResponse
+from freak.models.response import EngineResponse, Response
 from freak.types import LOCATOR_TYPE, Flow, Step
 
 
@@ -51,6 +51,13 @@ def get_step(self, from_step: Optional[str]) -> Step:
             raise Exception("InvalidStepError")
         return step
 
+    def get_next_step_uid(
+        self, resp_ctx: Response, next_steps: List[str]
+    ) -> str:
+        assert len(next_steps) == 1
+
+        return next_steps[0]
+
     def get_following_steps(
         self, from_step: Optional[str], path_traversed: Dict[str, Any]
     ) -> List[str]:
@@ -111,7 +118,9 @@ def execute(
             if not next_steps:
                 break
 
-            next_step_uid = next_steps[0]
+            next_step_uid = self.get_next_step_uid(
+                resp_ctx=resp_ctx, next_steps=next_steps
+            )
 
             next_steps = self.get_following_steps(
                 from_step=next_step_uid,
@@ -129,43 +138,21 @@ def execute(
             path_traversed,
         )
 
-    def inspect(
-        self,
-        from_step: Optional[str] = None,
-    ) -> List[Dict[str, Any]]:
-        responses = []
-        path_traversed: Dict[str, Any] = {"traversed": {}, "last_step": ""}
+    def inspect(self) -> Dict[str, Any]:
+        steps = self.flow.predecessor
+        steps_arr = []
+        [steps_arr.extend(value) for value in steps.values()]  # type: ignore
 
-        step = self.get_step(from_step=from_step)
-        next_steps = self.get_following_steps(
-            from_step=from_step,
-            path_traversed=path_traversed,
-        )
-
-        while True:
+        final_response = {}
+        for _step in steps_arr:
+            step = self.get_step(from_step=_step)
             ctx = FetchSchemaRequestContext(name=step.name, order=step.order)
 
             resp_ctx = step.function(ctx=ctx)  # type: ignore
-            responses.append(
-                {
-                    "name": step.name,
-                    "order": step.order,
-                    "schema": resp_ctx.output["schema"],
-                }
-            )
-
-            path_traversed["traversed"][step.uid] = next_steps
-            path_traversed["last_step"] = step.uid
-
-            if not next_steps:
-                break
-
-            next_step_uid = next_steps[0]
-
-            next_steps = self.get_following_steps(
-                from_step=next_step_uid,
-                path_traversed=path_traversed,
-            )
-            step = self.get_step(from_step=next_step_uid)
+            final_response[_step] = {
+                "name": step.name,
+                "order": step.order,
+                "schema": resp_ctx.output["schema"],
+            }
 
-        return responses
+        return {"graph": steps, "schema": final_response}

freak/flows/choice_flow.py

@@ -0,0 +1,118 @@
+"""
+    Note: Do not remove base_flow and locator import.
+"""
+
+
+from typing import Any, Dict, List, Optional, Tuple
+
+import copy
+
+from freak.engine import Engine
+from freak.flows.base_flow import base_flow as choice_flow
+from freak.flows.base_flow import locator
+from freak.models.request import RequestContext
+from freak.models.response import EngineResponse, Response
+
+
+class ChoiceFlowEngine(Engine):
+    def __init__(
+        self, module_name: str, decorator_name: str = "choice_flow"
+    ) -> None:
+        super().__init__(module_name=module_name, decorator_name=decorator_name)
+
+    def get_following_steps(
+        self, from_step: Optional[str], path_traversed: Dict[str, Any]
+    ) -> List[str]:
+        step_graph = self.flow.predecessor
+        if not from_step:
+            # pick up root of flow.
+            from_step = step_graph[from_step][0]
+
+        next_steps = step_graph.get(from_step, [])
+
+        last_step = path_traversed.get("last_step", "")
+        if from_step not in step_graph.get(last_step, []) and last_step:
+            raise Exception("CannotExecuteError")
+
+        return next_steps
+
+    def get_next_step_uid(
+        self, resp_ctx: Response, next_steps: List[str]
+    ) -> str:
+        if resp_ctx.choice:
+            if resp_ctx.choice not in next_steps:
+                raise Exception("InvalidChoice")
+
+            return resp_ctx.choice
+
+        assert len(next_steps) == 1
+
+        return next_steps[0]
+
+    def execute(
+        self,
+        from_step: Optional[str],
+        data: Dict[str, Any],
+        executed_steps: Dict[str, Any] = {"traversed": {}, "last_step": ""},
+    ) -> Tuple[EngineResponse, Dict[str, Any]]:
+        path_traversed = copy.deepcopy(executed_steps)
+
+        step = self.get_step(from_step=from_step)
+        next_steps = self.get_following_steps(
+            from_step=from_step,
+            path_traversed=path_traversed,
+        )
+
+        responses = []
+        last_successful_step, to_step, from_ = (
+            step.order,
+            step.order,
+            step.order,
+        )
+
+        while True:
+            ctx = RequestContext(input=data, name=step.name, order=step.order)
+
+            resp_ctx = step.function(ctx=ctx)  # type: ignore
+            responses.append(resp_ctx)
+            to_step = step.order  # this will refer to last performed step.
+            if not resp_ctx.success:
+                break
+
+            path = next_steps.copy()
+            if next_steps:
+                next_step_uid = self.get_next_step_uid(
+                    resp_ctx=resp_ctx, next_steps=next_steps
+                )
+                path = [next_step_uid]
+
+            path_traversed["traversed"][step.uid] = path
+            path_traversed["last_step"] = step.uid
+
+            data = resp_ctx.input
+
+            # this will refer last successfully performed action.
+            last_successful_step = step.order
+
+            if not next_steps:
+                break
+
+            next_step_uid = self.get_next_step_uid(
+                resp_ctx=resp_ctx, next_steps=next_steps
+            )
+
+            next_steps = self.get_following_steps(
+                from_step=next_step_uid,
+                path_traversed=path_traversed,
+            )
+            step = self.get_step(from_step=next_step_uid)
+
+        return (
+            EngineResponse(
+                responses=responses,
+                from_step=from_,
+                to_step=to_step,
+                last_successful_step=last_successful_step,
+            ),
+            path_traversed,
+        )

freak/models/input.py

@@ -24,3 +24,11 @@ class InputModelB(BaseModel):
     a: int
     b: int
     c: int
+
+
+class InputModelC(BaseModel):
+    """Class for defining structure of request data."""
+
+    a: int
+    b: int
+    d: int

freak/models/response.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 import abc
 import json
@@ -12,6 +12,7 @@ class Response(abc.ABC):
     messages: List[str]
     output: Dict[str, Any]
     success: bool
+    choice: Optional[str]
 
 
 class SuccessResponseContext(Response):
@@ -21,9 +22,15 @@ class SuccessResponseContext(Response):
     json_errors: str = ""
     messages: List[str] = []
 
-    def __init__(self, input: Dict[str, Any], output: Dict[str, Any]):
+    def __init__(
+        self,
+        input: Dict[str, Any],
+        output: Dict[str, Any],
+        choice: Optional[str] = None,
+    ):
         self.input = input
         self.output = output
+        self.choice = choice
 
 
 class ErrorResponseContext(Response):
@@ -32,6 +39,7 @@ class ErrorResponseContext(Response):
     output: Dict[str, Any] = {}
     success: bool = False
     json_errors: str = ""
+    choice: Optional[str] = None
 
     def __init__(self, input: Dict[str, Any], messages: List[str]) -> None:
         self.input = input
@@ -43,6 +51,7 @@ class InputErrorsResponseContext(Response):
     messages: List[str] = []
     output: Dict[str, Any] = {}
     success: bool = False
+    choice: Optional[str] = None
 
     def __init__(self, input: Dict[str, Any], json_errors: str):
         self.input = input
@@ -66,6 +75,7 @@ class FetchInputSchemaContext(Response):
     success: bool = field(default=True)
     json_errors: str = field(default="")
     input: Dict[str, Any] = {"fetch_schema": True}
+    choice: Optional[str] = None
 
     def __init__(self, output: Dict[str, Any]):
         self.output = output

freak/provider.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+import inspect
+from importlib import import_module
+
+
+class EngineProvider:
+    def __init__(self, flow_name: str) -> None:
+        look_here = f"freak.flows.{flow_name}"
+        module = import_module(name=look_here)
+        self.engine = self.find_engine(module=module)
+
+    def find_engine(self, module: object) -> Any:
+        from freak.engine import Engine
+
+        for _, cls in inspect.getmembers(module, inspect.isclass):
+            if issubclass(cls, Engine) and cls != Engine:
+                return cls
+        else:
+
+            return Engine