orchestracto-sdk 0.0.1__tar.gz

orchestracto_sdk-0.0.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.2
+Name: orchestracto-sdk
+Version: 0.0.1
+Author: TractoAI team
+Requires-Python: >=3.11
+Requires-Dist: orchestracto-client>=0.5.0
+Requires-Dist: PyYAML~=6.0.2
+Requires-Dist: requests~=2.32.3

orchestracto_sdk-0.0.1/orc_sdk/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.0.1"
+
+from orc_sdk.workflow import workflow
+from orc_sdk.step import task

orchestracto_sdk-0.0.1/orc_sdk/processor.py

@@ -0,0 +1,255 @@
+import argparse
+import dataclasses
+import datetime
+import importlib.util
+import inspect
+import os
+import os.path
+import subprocess
+import sys
+import tempfile
+from typing import Any
+
+import yaml
+
+from orc_client.client import OrcClient
+
+from orc_sdk.workflow import WorkflowRuntimeObject
+from orc_sdk.step import FuncStep, RetValWrapper
+
+
+def load_module(file_name, module_name):
+    spec = importlib.util.spec_from_file_location(module_name, file_name)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def compile_wf_config(wfro: WorkflowRuntimeObject) -> dict[str, Any]:
+    wf_config = {
+        "triggers": [],
+        "steps": [],
+    }
+
+    steps = wfro.get_steps()
+    for step_id, sci_info in steps.items():
+        if isinstance(sci_info.sci, FuncStep):
+            func_signature = inspect.signature(sci_info.sci.func)
+
+            passed_args = {}
+            for i, arg in enumerate(sci_info.sci.func_args):
+                arg_name = list(func_signature.parameters.keys())[i]  # FIXME??
+                passed_args[arg_name] = arg
+
+            for name, value in sci_info.sci.func_kwargs.items():
+                passed_args[name] = value
+
+            step_args = []
+            for i, name in enumerate(func_signature.parameters):
+                if name in passed_args:
+                    if isinstance(passed_args[name], RetValWrapper):
+                        src_type = "step_output"
+                        src_ref = f"{passed_args[name].sci.step_id}.{passed_args[name].name}"
+                    else:
+                        src_type = "constant"
+                        src_ref = passed_args[name]
+                else:
+                    src_type = "constant"
+                    src_ref = func_signature.parameters[name].default
+
+                step_args.append({
+                    "name": name,
+                    "src_type": src_type,
+                    "src_ref": src_ref,
+                })
+
+            secrets = []
+            for secret in sci_info.sci.secrets:
+                secrets.append({
+                    "key": secret.key,
+                    "value_ref": secret.value_ref,
+                    "value_src_type": secret.value_src_type,
+                })
+
+            wf_config["steps"].append({
+                "step_id": step_id,
+                "task_type": "docker",
+                "task_params": {
+                    "docker_image": "TODO",
+                    "command": sci_info.sci.func.__name__,
+                },
+                "args": step_args,
+                "secrets": secrets,
+                "outputs": [{
+                    "name": name,
+                } for name in sci_info.sci.retval_names],
+                "depends_on": list(sci_info.depends_on),
+                "cache": {
+                    "enable": sci_info.sci.cache.enable,
+                },
+            })
+        else:
+            raise NotImplementedError
+
+    wf_config["triggers"] = wfro.triggers
+
+    return wf_config
+
+
+def get_wfro_from_file(filename: str) -> WorkflowRuntimeObject:
+    module = load_module(filename, "user_code")
+    for key, obj in module.__dict__.items():
+        if getattr(obj, "is_workflow", False):
+            wfro = obj()  # TODO: args?
+            return wfro
+    else:
+        raise Exception("No workflow found")
+
+
+def get_file_module_root(filename: str) -> str:
+    dirname = os.path.dirname(os.path.abspath(filename))
+    if not os.path.exists(os.path.join(dirname, "__init__.py")):
+        return filename
+    return get_file_module_root(dirname)
+
+
+BASE_IMAGE = "cr.eu-north1.nebius.cloud/e00faee7vas5hpsh3s/orchestracto/sdk-simple-runtime:24"
+
+
+def login_in_registry(registry_url: str, token: str):
+    proc = subprocess.Popen(
+        ["docker", "login", registry_url, "--password-stdin", "-u", "user"],
+        stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr
+    )
+    proc.communicate(token.encode())
+    proc.wait()
+
+
+def build_docker_with_reqs(
+        workflow_path: str,
+        image_name: str,
+        wf_file_module: str,
+        additional_requirements: list[str],
+        base_image: str = BASE_IMAGE,
+) -> str:
+    py_packages_installation = f"""
+        RUN pip install -U {" ".join(additional_requirements)}
+        """ if additional_requirements else ""
+
+    dockerfile = f"""
+        FROM {BASE_IMAGE} AS sdk_runtime
+        FROM {base_image}
+        USER root
+        {py_packages_installation}
+        RUN mkdir /orc
+        COPY {os.path.basename(wf_file_module)} /orc/lib/{os.path.basename(wf_file_module)}
+        COPY --from=sdk_runtime /usr/local/lib/python3.12/site-packages/orc_sdk /orc/lib/orc_sdk
+        COPY --from=sdk_runtime /usr/local/bin/orc_run_step /usr/local/bin/orc_run_step
+        RUN new_shebang='#!/usr/bin/env python3' && sed -i "1s|.*|$new_shebang|" /usr/local/bin/orc_run_step
+        RUN chmod +x /usr/local/bin/orc_run_step
+    """
+
+    registry_url = os.environ.get("REGISTRY_URL")  # TODO: get from //sys/@ui_config?..
+    if registry_url is None:
+        registry_url = "registry." + os.environ["YT_PROXY"].removeprefix("https://").removeprefix("http://")
+
+    login_in_registry(registry_url, os.environ["YT_TOKEN"])
+
+    image_rel_path = workflow_path.removeprefix("//") + "/" + image_name
+    docker_tag = f"{registry_url}/home/orchestracto/public_registry/{image_rel_path}:latest"
+
+    with tempfile.NamedTemporaryFile() as tf:
+        with open(tf.name, "w") as f:
+            f.write(dockerfile)
+        subprocess.check_call(["docker", "build", "-t", docker_tag, "-f", tf.name, "--platform", "linux/amd64", os.path.dirname(wf_file_module), "--push"])
+
+    return docker_tag
+
+
+def get_docker_image_with_sha(docker_image: str) -> str:
+    return subprocess.check_output([
+        "docker", "inspect", "--format", "{{index .RepoDigests 0}}", docker_image
+    ]).decode().strip()
+
+
+@dataclasses.dataclass
+class WorkflowInfo:
+    workflow_path: str
+    workflow_config: dict[str, Any]
+
+
+def get_wf_info_from_file(filename: str) -> WorkflowInfo:
+    wfro = get_wfro_from_file(filename)
+    wf_config = compile_wf_config(wfro)
+
+    wf_file_module = get_file_module_root(filename)
+
+    if os.path.abspath(wf_file_module) != os.path.abspath(filename):
+        wf_file_module_dir = os.path.dirname(wf_file_module)  # FIXME
+        rel_file_path = os.path.abspath(filename).removeprefix(wf_file_module_dir + "/")
+    else:
+        rel_file_path = os.path.basename(filename)  # TODO FIXME
+    path_in_container = f"/orc/lib/{rel_file_path}"
+
+    default_docker_tag = build_docker_with_reqs(
+        wfro.workflow_path, "default",
+        wf_file_module,
+        wfro.additional_requirements
+    )
+
+    wfro_steps = wfro.get_steps()
+
+    for step in wf_config["steps"]:
+        step_id = step["step_id"]
+        sci = wfro_steps[step_id].sci
+        assert isinstance(sci, FuncStep)
+        if sci.additional_requirements or sci.base_image:
+            docker_tag = build_docker_with_reqs(
+                wfro.workflow_path, step_id,
+                wf_file_module,
+                wfro.additional_requirements + sci.additional_requirements,
+                base_image=sci.base_image or BASE_IMAGE,
+            )
+            step["task_params"]["docker_image"] = docker_tag
+        else:
+            step["task_params"]["docker_image"] = default_docker_tag
+
+        step["task_params"]["env"] = {"PYTHONPATH": "/orc/lib", "YT_BASE_LAYER": step["task_params"]["docker_image"]}
+        step["task_params"]["command"] = f"orc_run_step {path_in_container} {step_id} >&2"  # FIXME: corrupts cache key
+        step["task_params"]["func_code_hash"] = sci.func_code_hash
+
+    return WorkflowInfo(workflow_path=wfro.workflow_path, workflow_config=wf_config)
+
+
+def process_python_file(filename: str):
+    wf_info = get_wf_info_from_file(filename)
+
+    if "ORC_URL" not in os.environ:
+        yt_proxy = os.environ.get("YT_PROXY")
+        if yt_proxy is None:
+            raise ValueError("Either ORC_URL or YT_PROXY environment variable should be set")
+        orc_url = "https://orc." + yt_proxy.removeprefix("https://").removeprefix("http://")
+    else:
+        orc_url = os.environ["ORC_URL"]
+
+    orc_client = OrcClient(orc_url=orc_url, yt_token=os.environ["YT_TOKEN"])
+    orc_client.update_workflow(wf_info.workflow_path, wf_info.workflow_config)
+
+
+def configure_arg_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    subparsers = parser.add_subparsers(dest="command")
+
+    get_config = subparsers.add_parser("get-config")
+    get_config.add_argument("filename", type=str)
+
+    process_parser = subparsers.add_parser("process")
+    process_parser.add_argument("filename", type=str)
+
+    return parser
+
+
+def process_args(args: argparse.Namespace):
+    match args.command:
+        case "process":
+            process_python_file(args.filename)

orchestracto_sdk-0.0.1/orc_sdk/run_step.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+import argparse
+import importlib.util
+import json
+import os
+import sys
+
+from orc_sdk.step import FuncStep
+
+
+def load_module(file_name, module_name):  # FIXME: duplicate
+    spec = importlib.util.spec_from_file_location(module_name, file_name)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("pyfile_with_workflow")
+    parser.add_argument("step_id")
+    parser.add_argument("--base-layer")
+
+    args = parser.parse_args()
+
+    module = load_module(args.pyfile_with_workflow, "workflow")
+
+    for key, obj in module.__dict__.items():
+        if getattr(obj, "is_workflow", False):
+            wfro = obj()
+            break
+    else:
+        raise Exception("No workflow found")
+
+    steps = wfro.get_steps()
+    the_step_sci = steps[args.step_id].sci
+
+    if not isinstance(the_step_sci, FuncStep):
+        raise NotImplementedError
+
+    for key, value in os.environ.items():
+        if key.startswith("YT_SECURE_VAULT_"):
+            os.environ[key.removeprefix("YT_SECURE_VAULT_")] = value
+
+    returned_values = the_step_sci.run()
+
+    if len(the_step_sci.retval_names) > 0:
+        if not isinstance(returned_values, tuple):
+            returned_values = (returned_values,)
+
+        ret_dict = {}
+        for idx, value in enumerate(returned_values):
+            ret_dict[the_step_sci.retval_names[idx]] = value
+
+        print(json.dumps(ret_dict))
+
+
+if __name__ == "__main__":
+    main()

orchestracto_sdk-0.0.1/orc_sdk/step.py

@@ -0,0 +1,146 @@
+import dataclasses
+import hashlib
+import inspect
+import os
+from typing import Callable, Any, Self
+from functools import wraps
+from collections import defaultdict
+
+from orc_sdk.step_chain import StepChainItem
+from orc_sdk.utils import random_string
+
+
+@dataclasses.dataclass
+class RetValWrapper:
+    value: Any
+    sci: StepChainItem
+    name: str
+
+
+@dataclasses.dataclass
+class SecretRecord:
+    key: str
+    value_ref: str
+    value_src_type: str
+
+
+@dataclasses.dataclass
+class SecretsMixin:
+    secrets: list[SecretRecord] = dataclasses.field(default_factory=list)
+
+    def with_secret(self, key: str, value_ref: str, value_src_type: str) -> Self:
+        self.secrets.append(SecretRecord(key=key, value_ref=value_ref, value_src_type=value_src_type))
+        return self
+
+
+@dataclasses.dataclass
+class CacheSettings:
+    enable: bool = dataclasses.field(default=False)
+    enable_write: bool | None = dataclasses.field(default=None)
+    enable_read: bool | None = dataclasses.field(default=None)
+    cache_version: str = dataclasses.field(default="v1")
+
+
+@dataclasses.dataclass
+class CacheMixin:
+    cache: CacheSettings = dataclasses.field(default_factory=CacheSettings)
+
+    def with_cache(self, version: str | None = None) -> Self:
+        self.cache.enable = True
+        if version is not None:
+            self.cache.cache_version = version
+        return self
+
+
+@dataclasses.dataclass
+class Step(StepChainItem):
+    task_type: str
+    task_params: dict[str, Any]
+
+
+@dataclasses.dataclass
+class FuncStep(SecretsMixin, CacheMixin, StepChainItem):
+    func: Callable[..., Any] = dataclasses.field(default_factory=lambda: None)
+    func_args: tuple[Any, ...] = dataclasses.field(default_factory=list)
+    func_kwargs: dict = dataclasses.field(default_factory=dict)
+    retval_names: list[str] = dataclasses.field(default_factory=list)
+    additional_requirements: list[str] = dataclasses.field(default_factory=list)
+    base_image: str | None = dataclasses.field(default=None)
+    func_code_hash: str | None = dataclasses.field(default=None)
+
+    def __post_init__(self):
+        super().__post_init__()
+        for arg in self.func_args + tuple(self.func_kwargs.values()):
+            if isinstance(arg, RetValWrapper):
+                if arg.sci.step_id not in [ps.step_id for ps in self._prev_steps]:  # TODO: traverse
+                    self._prev_steps.append(arg.sci)
+                    arg.sci._next_steps.append(self)
+                    self._first.extend(arg.sci._first)
+
+
+    def with_additional_requirements(self, additional_requirements: list[str]) -> Self:
+        self.additional_requirements = additional_requirements
+        return self
+
+    def with_base_image(self, base_image: str) -> Self:
+        self.base_image = base_image
+        return self
+
+    @property
+    def outputs(self):
+        ret_vars = inspect.signature(self.func).return_annotation
+        if ret_vars is tuple:
+            # TODO
+            pass
+        else:
+            parameters = {
+                self.retval_names[0]: RetValWrapper(value=ret_vars, sci=self, name=self.retval_names[0])}
+            name = self.func.__name__.capitalize()
+            cls = type(name, (), parameters)
+            return dataclasses.dataclass(cls)
+
+    def run(self):
+        processed_args = []
+        processed_kwargs = {}
+        func_signature = inspect.signature(self.func)
+
+        for i, arg in enumerate(self.func_args):
+            if isinstance(arg, RetValWrapper):
+                processed_args.append(os.environ[f"ORC_PARAM_{list(func_signature.parameters.keys())[i]}"])
+            else:
+                processed_args.append(arg)
+
+        for key, value in self.func_kwargs.items():
+            if isinstance(value, RetValWrapper):
+                processed_kwargs[key] = os.environ[f"ORC_PARAM_{key}"]
+            else:
+                processed_kwargs[key] = value
+
+        return self.func(*processed_args, **processed_kwargs)
+
+
+FUNC_NAME_COUNTER = defaultdict(lambda: 0)
+
+
+def task(retval_names: list[str] | None = None) -> Callable[[Callable[..., Any]], Callable[..., FuncStep]]:
+    def decorator(function: Callable[..., Any]) -> Callable[..., FuncStep]:
+        @wraps(function)
+        def wrapper(*args, **kwargs) -> FuncStep:
+            FUNC_NAME_COUNTER[function.__name__] += 1
+            sro_id = function.__name__ + "_" + str(FUNC_NAME_COUNTER[function.__name__])
+            func_code_hash = hashlib.md5(inspect.getsource(function).encode()).hexdigest()
+
+            nonlocal retval_names
+            if retval_names is None and inspect.signature(function).return_annotation is not inspect._empty:
+                num_outputs = 1 if not inspect.signature(function).return_annotation is tuple else len(inspect.signature(function).return_annotation)
+                retval_names = [f"output_{i}" for i in range(1, num_outputs + 1)]
+
+            sro = FuncStep(
+                step_id=sro_id, func=function, func_args=args, func_kwargs=kwargs,
+                retval_names=retval_names or [], func_code_hash=func_code_hash,
+            )
+            return sro
+
+        return wrapper
+
+    return decorator

orchestracto_sdk-0.0.1/orc_sdk/step_chain.py

@@ -0,0 +1,58 @@
+import dataclasses
+from typing import Self
+
+
+@dataclasses.dataclass
+class StepChainItem:
+    step_id: str
+
+    _first: list["StepChainItem"] = dataclasses.field(init=False)
+    _next_steps: list["StepChainItem"] = dataclasses.field(init=False)
+    _prev_steps: list["StepChainItem"] = dataclasses.field(init=False)
+
+    def __post_init__(self):
+        self._first = [self]
+        self._next_steps = []
+        self._prev_steps = []
+
+    def __rshift__(self, other: Self | list[Self]) -> Self:
+        self.set_downstream(other)
+        return other
+
+    def __lshift__(self, other: Self | list[Self]) -> Self | list[Self]:
+        self.set_upstream(other)
+        return other
+
+    def __rrshift__(self, other: Self | list[Self]) -> Self:
+        self.__lshift__(other)
+        return self
+
+    def __rlshift__(self, other: Self | list[Self]):
+        self.__rrshift__(other)
+        return self
+
+    def set_downstream(self, other: Self | list[Self]):
+        if isinstance(other, list):
+            for sro in other:
+                sro._first = self._first
+                self._next_steps.append(sro)
+                sro._prev_steps.append(self)
+        else:
+            other._first = self._first
+            self._next_steps.append(other)
+            other._prev_steps.append(self)
+
+    def set_upstream(self, other: Self | list[Self]):
+        if isinstance(other, list):
+            for sro in other:
+                sro._next_steps.append(self)
+                self._prev_steps.append(sro)
+            self._first = other[0]._first
+        else:
+            other._next_steps.append(self)
+            self._first = other._first
+            self._prev_steps.append(other)
+
+    def with_id(self, step_id: str) -> Self:
+        self.step_id = step_id
+        return self

orchestracto_sdk-0.0.1/orc_sdk/utils.py

@@ -0,0 +1,6 @@
+import random
+import string
+
+
+def random_string(length: int) -> str:
+    return "".join(random.choices(string.ascii_uppercase + string.digits, k=length))

orchestracto_sdk-0.0.1/orc_sdk/workflow.py

@@ -0,0 +1,82 @@
+import inspect
+import dataclasses
+from typing import Any
+from functools import wraps
+
+from orc_sdk.step_chain import StepChainItem
+
+
+@dataclasses.dataclass
+class SCIInfo:
+    sci: StepChainItem
+    depends_on: set[str]
+
+
+class WorkflowRuntimeObject:
+    def __init__(
+            self, workflow_path: str, triggers: list[Any],
+            additional_requirements: list[str]
+    ):
+        self.workflow_path = workflow_path
+        self.triggers = triggers
+
+        self.additional_requirements = additional_requirements
+
+        self.first_steps = []
+
+
+    def register_first_step(self, step: StepChainItem) -> StepChainItem:
+        self.first_steps.append(step)
+        return step
+
+    def get_steps(self):
+        steps: dict[str, SCIInfo] = {}
+
+        scis_to_inspect: list[tuple[StepChainItem, str | None]] = [(sci, None) for sci in self.first_steps]
+
+        while scis_to_inspect:
+            sci, parent = scis_to_inspect.pop(0)
+
+            if sci.step_id in steps:
+                assert parent is not None
+                steps[sci.step_id].depends_on.add(parent)
+            elif parent is not None:
+                steps[sci.step_id] = SCIInfo(sci, {parent})
+            else:
+                steps[sci.step_id] = SCIInfo(sci, set())
+
+            for next_sro in sci._next_steps:
+                scis_to_inspect.append((next_sro, sci.step_id))
+
+        return steps
+
+
+@dataclasses.dataclass
+class WfArgWrapper:
+    value: Any
+    name: str
+
+
+def workflow(workflow_path: str, triggers: list[Any] | None = None, additional_requirements: list[str] | None = None):
+    def decorator(function):
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            wfro = WorkflowRuntimeObject(
+                workflow_path,
+                triggers=triggers or [],
+                additional_requirements=additional_requirements or [],
+            )
+
+            wrapped_args = []
+            for arg in inspect.signature(function).parameters.values():
+                wrapped_args.append(WfArgWrapper(value=arg.default, name=arg.name))
+
+            wrapped_args[0] = wfro
+            step_chain_item = function(*wrapped_args)
+            wfro.step_chain_item = step_chain_item
+            return wfro
+
+        wrapper.is_workflow = True
+        return wrapper
+
+    return decorator

orchestracto_sdk-0.0.1/orchestracto_sdk.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.2
+Name: orchestracto-sdk
+Version: 0.0.1
+Author: TractoAI team
+Requires-Python: >=3.11
+Requires-Dist: orchestracto-client>=0.5.0
+Requires-Dist: PyYAML~=6.0.2
+Requires-Dist: requests~=2.32.3

orchestracto_sdk-0.0.1/orchestracto_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+pyproject.toml
+orc_sdk/__init__.py
+orc_sdk/processor.py
+orc_sdk/run_step.py
+orc_sdk/step.py
+orc_sdk/step_chain.py
+orc_sdk/utils.py
+orc_sdk/workflow.py
+orchestracto_sdk.egg-info/PKG-INFO
+orchestracto_sdk.egg-info/SOURCES.txt
+orchestracto_sdk.egg-info/dependency_links.txt
+orchestracto_sdk.egg-info/entry_points.txt
+orchestracto_sdk.egg-info/requires.txt
+orchestracto_sdk.egg-info/top_level.txt
+tests/test_main.py

orchestracto_sdk-0.0.1/orchestracto_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

orchestracto_sdk-0.0.1/orchestracto_sdk.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+orc_run_step = orc_sdk.run_step:main
+orcsdk = orc_sdk.processor:main_cli

orchestracto_sdk-0.0.1/orchestracto_sdk.egg-info/requires.txt

@@ -0,0 +1,3 @@
+orchestracto-client>=0.5.0
+PyYAML~=6.0.2
+requests~=2.32.3

orchestracto_sdk-0.0.1/orchestracto_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+orc_sdk

orchestracto_sdk-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "orchestracto-sdk"
+authors = [{name = "TractoAI team"}]
+requires-python = ">=3.11"
+dependencies = [
+    "orchestracto-client>=0.5.0",
+    "PyYAML~=6.0.2",
+    "requests~=2.32.3",
+]
+dynamic = ["version"]
+
+[tool.setuptools]
+packages = ["orc_sdk"]
+
+[tool.setuptools.dynamic]
+version = {attr = "orc_sdk.__version__"}
+
+[project.scripts]
+orcsdk = "orc_sdk.processor:main_cli"
+orc_run_step = "orc_sdk.run_step:main"

orchestracto_sdk-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

orchestracto_sdk-0.0.1/tests/test_main.py

@@ -0,0 +1,66 @@
+from orc_sdk.main import workflow, task, SROBlock, get_steps
+
+
+def test_main():
+
+    @task()
+    def foo():
+        print("foo")
+
+    @task()
+    def bar(key: str):
+        print(f"bar {key}")
+
+    @task()
+    def xyz():
+        print("xyz")
+
+    @task()
+    def abc():
+        print("abc")
+
+    #
+    #                    /foo \
+    #                abc/       xyz\
+    #              /     \ bar/      \
+    #  foo -> bar /                     \
+    #             \      foo-------------bar
+    #               xyz/
+    #                   \bar
+    #
+
+    foo_step = foo()
+
+    bar_step = foo_step >> bar(key="some_key")
+
+    abc_step = bar_step >> abc()
+    xyz_step = bar_step >> xyz()
+
+    last_xyz_step = abc_step >> SROBlock(foo(), bar()) >> xyz()
+
+    xyz_step >> bar()
+    last_foo_step = xyz_step >> foo()
+
+    last_bar_step = SROBlock(last_xyz_step, last_foo_step) >> bar()
+
+    stlist = get_steps(foo_step)
+    pass
+
+
+def test_simple():
+    @task()
+    def foo():
+        print("foo")
+
+    @task()
+    def bar():
+        print("bar")
+
+    @task()
+    def fin():
+        print("fin")
+
+    foobar = SROBlock(foo().with_id("the_foo"), bar().with_id("the_bar"))
+    foobar >> fin().with_id("the_fin")
+
+    pass